prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Linq.Expressions;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.Text.Json;
using System.Threading.Tasks;
using Magic.IndexedDb.Helpers;
using Magic.IndexedDb.Models;
using Magic.IndexedDb.SchemaAnnotations;
using Microsoft.JSInterop;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using static System.Collections.Specialized.BitVector32;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace Magic.IndexedDb
{
/// <summary>
/// Provides functionality for accessing IndexedDB from Blazor application
/// </summary>
public class IndexedDbManager
{
readonly DbStore _dbStore;
readonly IJSRuntime _jsRuntime;
const string InteropPrefix = "window.magicBlazorDB";
DotNetObjectReference<IndexedDbManager> _objReference;
IDictionary<Guid, WeakReference<Action<BlazorDbEvent>>> _transactions = new Dictionary<Guid, WeakReference<Action<BlazorDbEvent>>>();
IDictionary<Guid, TaskCompletionSource<BlazorDbEvent>> _taskTransactions = new Dictionary<Guid, TaskCompletionSource<BlazorDbEvent>>();
private IJSObjectReference? _module { get; set; }
/// <summary>
/// A notification event that is raised when an action is completed
/// </summary>
public event EventHandler< | BlazorDbEvent> ActionCompleted; |
/// <summary>
/// Ctor
/// </summary>
/// <param name="dbStore"></param>
/// <param name="jsRuntime"></param>
#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
internal IndexedDbManager(DbStore dbStore, IJSRuntime jsRuntime)
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
{
_objReference = DotNetObjectReference.Create(this);
_dbStore = dbStore;
_jsRuntime = jsRuntime;
}
public async Task<IJSObjectReference> GetModule(IJSRuntime jsRuntime)
{
if (_module == null)
{
_module = await jsRuntime.InvokeAsync<IJSObjectReference>("import", "./_content/Magic.IndexedDb/magicDB.js");
}
return _module;
}
public List<StoreSchema> Stores => _dbStore.StoreSchemas;
public string CurrentVersion => _dbStore.Version;
public string DbName => _dbStore.Name;
/// <summary>
/// Opens the IndexedDB defined in the DbStore. Under the covers will create the database if it does not exist
/// and create the stores defined in DbStore.
/// </summary>
/// <returns></returns>
public async Task<Guid> OpenDb(Action<BlazorDbEvent>? action = null)
{
var trans = GenerateTransaction(action);
await CallJavascriptVoid(IndexedDbFunctions.CREATE_DB, trans, _dbStore);
return trans;
}
/// <summary>
/// Deletes the database corresponding to the dbName passed in
/// </summary>
/// <param name="dbName">The name of database to delete</param>
/// <returns></returns>
public async Task<Guid> DeleteDb(string dbName, Action<BlazorDbEvent>? action = null)
{
if (string.IsNullOrEmpty(dbName))
{
throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
}
var trans = GenerateTransaction(action);
await CallJavascriptVoid(IndexedDbFunctions.DELETE_DB, trans, dbName);
return trans;
}
/// <summary>
/// Deletes the database corresponding to the dbName passed in
/// Waits for response
/// </summary>
/// <param name="dbName">The name of database to delete</param>
/// <returns></returns>
public async Task<BlazorDbEvent> DeleteDbAsync(string dbName)
{
if (string.IsNullOrEmpty(dbName))
{
throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
}
var trans = GenerateTransaction();
await CallJavascriptVoid(IndexedDbFunctions.DELETE_DB, trans.trans, dbName);
return await trans.task;
}
/// <summary>
/// Adds a new record/object to the specified store
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="recordToAdd">An instance of StoreRecord that provides the store name and the data to add</param>
/// <returns></returns>
private async Task<Guid> AddRecord<T>(StoreRecord<T> recordToAdd, Action<BlazorDbEvent>? action = null)
{
var trans = GenerateTransaction(action);
try
{
recordToAdd.DbName = DbName;
await CallJavascriptVoid(IndexedDbFunctions.ADD_ITEM, trans, recordToAdd);
}
catch (JSException e)
{
RaiseEvent(trans, true, e.Message);
}
return trans;
}
public async Task<Guid> Add<T>(T record, Action<BlazorDbEvent>? action = null) where T : class
{
string schemaName = SchemaHelper.GetSchemaName<T>();
T? myClass = null;
object? processedRecord = await ProcessRecord(record);
if (processedRecord is ExpandoObject)
myClass = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(processedRecord));
else
myClass = (T?)processedRecord;
var trans = GenerateTransaction(action);
try
{
Dictionary<string, object?>? convertedRecord = null;
if (processedRecord is ExpandoObject)
{
var result = ((ExpandoObject)processedRecord)?.ToDictionary(kv => kv.Key, kv => (object?)kv.Value);
if (result != null)
{
convertedRecord = result;
}
}
else
{
convertedRecord = ManagerHelper.ConvertRecordToDictionary(myClass);
}
var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
// Convert the property names in the convertedRecord dictionary
if (convertedRecord != null)
{
var updatedRecord = ManagerHelper.ConvertPropertyNamesUsingMappings(convertedRecord, propertyMappings);
if (updatedRecord != null)
{
StoreRecord<Dictionary<string, object?>> RecordToSend = new StoreRecord<Dictionary<string, object?>>()
{
DbName = this.DbName,
StoreName = schemaName,
Record = updatedRecord
};
await CallJavascriptVoid(IndexedDbFunctions.ADD_ITEM, trans, RecordToSend);
}
}
}
catch (JSException e)
{
RaiseEvent(trans, true, e.Message);
}
return trans;
}
public async Task<string> Decrypt(string EncryptedValue)
{
EncryptionFactory encryptionFactory = new EncryptionFactory(_jsRuntime, this);
string decryptedValue = await encryptionFactory.Decrypt(EncryptedValue, _dbStore.EncryptionKey);
return decryptedValue;
}
private async Task<object?> ProcessRecord<T>(T record) where T : class
{
string schemaName = SchemaHelper.GetSchemaName<T>();
StoreSchema? storeSchema = Stores.FirstOrDefault(s => s.Name == schemaName);
if (storeSchema == null)
{
throw new InvalidOperationException($"StoreSchema not found for '{schemaName}'");
}
// Encrypt properties with EncryptDb attribute
var propertiesToEncrypt = typeof(T).GetProperties()
.Where(p => p.GetCustomAttributes(typeof(MagicEncryptAttribute), false).Length > 0);
EncryptionFactory encryptionFactory = new EncryptionFactory(_jsRuntime, this);
foreach (var property in propertiesToEncrypt)
{
if (property.PropertyType != typeof(string))
{
throw new InvalidOperationException("EncryptDb attribute can only be used on string properties.");
}
string? originalValue = property.GetValue(record) as string;
if (!string.IsNullOrWhiteSpace(originalValue))
{
string encryptedValue = await encryptionFactory.Encrypt(originalValue, _dbStore.EncryptionKey);
property.SetValue(record, encryptedValue);
}
else
{
property.SetValue(record, originalValue);
}
}
// Proceed with adding the record
if (storeSchema.PrimaryKeyAuto)
{
var primaryKeyProperty = typeof(T)
.GetProperties()
.FirstOrDefault(p => p.GetCustomAttributes(typeof(MagicPrimaryKeyAttribute), false).Length > 0);
if (primaryKeyProperty != null)
{
Dictionary<string, object?> recordAsDict;
var primaryKeyValue = primaryKeyProperty.GetValue(record);
if (primaryKeyValue == null || primaryKeyValue.Equals(GetDefaultValue(primaryKeyValue.GetType())))
{
recordAsDict = typeof(T).GetProperties()
.Where(p => p.Name != primaryKeyProperty.Name && p.GetCustomAttributes(typeof(MagicNotMappedAttribute), false).Length == 0)
.ToDictionary(p => p.Name, p => p.GetValue(record));
}
else
{
recordAsDict = typeof(T).GetProperties()
.Where(p => p.GetCustomAttributes(typeof(MagicNotMappedAttribute), false).Length == 0)
.ToDictionary(p => p.Name, p => p.GetValue(record));
}
// Create a new ExpandoObject and copy the key-value pairs from the dictionary
var expandoRecord = new ExpandoObject() as IDictionary<string, object?>;
foreach (var kvp in recordAsDict)
{
expandoRecord.Add(kvp);
}
return expandoRecord as ExpandoObject;
}
}
return record;
}
// Returns the default value for the given type
private static object? GetDefaultValue(Type type)
{
return type.IsValueType ? Activator.CreateInstance(type) : null;
}
/// <summary>
/// Adds records/objects to the specified store in bulk
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="recordsToBulkAdd">The data to add</param>
/// <returns></returns>
private async Task<Guid> BulkAddRecord<T>(string storeName, IEnumerable<T> recordsToBulkAdd, Action<BlazorDbEvent>? action = null)
{
var trans = GenerateTransaction(action);
try
{
await CallJavascriptVoid(IndexedDbFunctions.BULKADD_ITEM, trans, DbName, storeName, recordsToBulkAdd);
}
catch (JSException e)
{
RaiseEvent(trans, true, e.Message);
}
return trans;
}
//public async Task<Guid> AddRange<T>(IEnumerable<T> records, Action<BlazorDbEvent> action = null) where T : class
//{
// string schemaName = SchemaHelper.GetSchemaName<T>();
// var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
// List<object> processedRecords = new List<object>();
// foreach (var record in records)
// {
// object processedRecord = await ProcessRecord(record);
// if (processedRecord is ExpandoObject)
// {
// var convertedRecord = ((ExpandoObject)processedRecord).ToDictionary(kv => kv.Key, kv => (object)kv.Value);
// processedRecords.Add(ManagerHelper.ConvertPropertyNamesUsingMappings(convertedRecord, propertyMappings));
// }
// else
// {
// var convertedRecord = ManagerHelper.ConvertRecordToDictionary((T)processedRecord);
// processedRecords.Add(ManagerHelper.ConvertPropertyNamesUsingMappings(convertedRecord, propertyMappings));
// }
// }
// return await BulkAddRecord(schemaName, processedRecords, action);
//}
/// <summary>
/// Adds records/objects to the specified store in bulk
/// Waits for response
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="recordsToBulkAdd">An instance of StoreRecord that provides the store name and the data to add</param>
/// <returns></returns>
private async Task<BlazorDbEvent> BulkAddRecordAsync<T>(string storeName, IEnumerable<T> recordsToBulkAdd)
{
var trans = GenerateTransaction();
try
{
await CallJavascriptVoid(IndexedDbFunctions.BULKADD_ITEM, trans.trans, DbName, storeName, recordsToBulkAdd);
}
catch (JSException e)
{
RaiseEvent(trans.trans, true, e.Message);
}
return await trans.task;
}
public async Task AddRange<T>(IEnumerable<T> records) where T : class
{
string schemaName = SchemaHelper.GetSchemaName<T>();
//var trans = GenerateTransaction(null);
//var TableCount = await CallJavascript<int>(IndexedDbFunctions.COUNT_TABLE, trans, DbName, schemaName);
List<Dictionary<string, object?>> processedRecords = new List<Dictionary<string, object?>>();
foreach (var record in records)
{
bool IsExpando = false;
T? myClass = null;
object? processedRecord = await ProcessRecord(record);
if (processedRecord is ExpandoObject)
{
myClass = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(processedRecord));
IsExpando = true;
}
else
myClass = (T?)processedRecord;
Dictionary<string, object?>? convertedRecord = null;
if (processedRecord is ExpandoObject)
{
var result = ((ExpandoObject)processedRecord)?.ToDictionary(kv => kv.Key, kv => (object?)kv.Value);
if (result != null)
convertedRecord = result;
}
else
{
convertedRecord = ManagerHelper.ConvertRecordToDictionary(myClass);
}
var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
// Convert the property names in the convertedRecord dictionary
if (convertedRecord != null)
{
var updatedRecord = ManagerHelper.ConvertPropertyNamesUsingMappings(convertedRecord, propertyMappings);
if (updatedRecord != null)
{
if (IsExpando)
{
//var test = updatedRecord.Cast<Dictionary<string, object>();
var dictionary = updatedRecord as Dictionary<string, object?>;
processedRecords.Add(dictionary);
}
else
{
processedRecords.Add(updatedRecord);
}
}
}
}
await BulkAddRecordAsync(schemaName, processedRecords);
}
public async Task<Guid> Update<T>(T item, Action<BlazorDbEvent>? action = null) where T : class
{
var trans = GenerateTransaction(action);
try
{
string schemaName = SchemaHelper.GetSchemaName<T>();
PropertyInfo? primaryKeyProperty = typeof(T).GetProperties().FirstOrDefault(prop => Attribute.IsDefined(prop, typeof(MagicPrimaryKeyAttribute)));
if (primaryKeyProperty != null)
{
object? primaryKeyValue = primaryKeyProperty.GetValue(item);
var convertedRecord = ManagerHelper.ConvertRecordToDictionary(item);
if (primaryKeyValue != null)
{
UpdateRecord<Dictionary<string, object?>> record = new UpdateRecord<Dictionary<string, object?>>()
{
Key = primaryKeyValue,
DbName = this.DbName,
StoreName = schemaName,
Record = convertedRecord
};
// Get the primary key value of the item
await CallJavascriptVoid(IndexedDbFunctions.UPDATE_ITEM, trans, record);
}
else
{
throw new ArgumentException("Item being updated must have a key.");
}
}
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return trans;
}
public async Task<Guid> UpdateRange<T>(IEnumerable<T> items, Action<BlazorDbEvent>? action = null) where T : class
{
var trans = GenerateTransaction(action);
try
{
string schemaName = SchemaHelper.GetSchemaName<T>();
PropertyInfo? primaryKeyProperty = typeof(T).GetProperties().FirstOrDefault(prop => Attribute.IsDefined(prop, typeof(MagicPrimaryKeyAttribute)));
if (primaryKeyProperty != null)
{
List<UpdateRecord<Dictionary<string, object?>>> recordsToUpdate = new List<UpdateRecord<Dictionary<string, object?>>>();
foreach (var item in items)
{
object? primaryKeyValue = primaryKeyProperty.GetValue(item);
var convertedRecord = ManagerHelper.ConvertRecordToDictionary(item);
if (primaryKeyValue != null)
{
recordsToUpdate.Add(new UpdateRecord<Dictionary<string, object?>>()
{
Key = primaryKeyValue,
DbName = this.DbName,
StoreName = schemaName,
Record = convertedRecord
});
}
await CallJavascriptVoid(IndexedDbFunctions.BULKADD_UPDATE, trans, recordsToUpdate);
}
}
else
{
throw new ArgumentException("Item being update range item must have a key.");
}
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return trans;
}
public async Task<TResult?> GetById<TResult>(object key) where TResult : class
{
string schemaName = SchemaHelper.GetSchemaName<TResult>();
// Find the primary key property
var primaryKeyProperty = typeof(TResult)
.GetProperties()
.FirstOrDefault(p => p.GetCustomAttributes(typeof(MagicPrimaryKeyAttribute), false).Length > 0);
if (primaryKeyProperty == null)
{
throw new InvalidOperationException("No primary key property found with PrimaryKeyDbAttribute.");
}
// Check if the key is of the correct type
if (!primaryKeyProperty.PropertyType.IsInstanceOfType(key))
{
throw new ArgumentException($"Invalid key type. Expected: {primaryKeyProperty.PropertyType}, received: {key.GetType()}");
}
var trans = GenerateTransaction(null);
string columnName = primaryKeyProperty.GetPropertyColumnName<MagicPrimaryKeyAttribute>();
var data = new { DbName = DbName, StoreName = schemaName, Key = columnName, KeyValue = key };
try
{
var propertyMappings = ManagerHelper.GeneratePropertyMapping<TResult>();
var RecordToConvert = await CallJavascript<Dictionary<string, object>>(IndexedDbFunctions.FIND_ITEMV2, trans, data.DbName, data.StoreName, data.KeyValue);
if (RecordToConvert != null)
{
var ConvertedResult = ConvertIndexedDbRecordToCRecord<TResult>(RecordToConvert, propertyMappings);
return ConvertedResult;
}
else
{
return default(TResult);
}
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return default(TResult);
}
public MagicQuery<T> Where<T>(Expression<Func<T, bool>> predicate) where T : class
{
string schemaName = SchemaHelper.GetSchemaName<T>();
MagicQuery<T> query = new MagicQuery<T>(schemaName, this);
// Preprocess the predicate to break down Any and All expressions
var preprocessedPredicate = PreprocessPredicate(predicate);
var asdf = preprocessedPredicate.ToString();
CollectBinaryExpressions(preprocessedPredicate.Body, preprocessedPredicate, query.JsonQueries);
return query;
}
private Expression<Func<T, bool>> PreprocessPredicate<T>(Expression<Func<T, bool>> predicate)
{
var visitor = new PredicateVisitor<T>();
var newExpression = visitor.Visit(predicate.Body);
return Expression.Lambda<Func<T, bool>>(newExpression, predicate.Parameters);
}
internal async Task<IList<T>?> WhereV2<T>(string storeName, List<string> jsonQuery, MagicQuery<T> query) where T : class
{
var trans = GenerateTransaction(null);
try
{
string? jsonQueryAdditions = null;
if (query != null && query.storedMagicQueries != null && query.storedMagicQueries.Count > 0)
{
jsonQueryAdditions = Newtonsoft.Json.JsonConvert.SerializeObject(query.storedMagicQueries.ToArray());
}
var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
IList<Dictionary<string, object>>? ListToConvert =
await CallJavascript<IList<Dictionary<string, object>>>
(IndexedDbFunctions.WHEREV2, trans, DbName, storeName, jsonQuery.ToArray(), jsonQueryAdditions!, query?.ResultsUnique!);
var resultList = ConvertListToRecords<T>(ListToConvert, propertyMappings);
return resultList;
}
catch (Exception jse)
{
RaiseEvent(trans, true, jse.Message);
}
return default;
}
private void CollectBinaryExpressions<T>(Expression expression, Expression<Func<T, bool>> predicate, List<string> jsonQueries) where T : class
{
var binaryExpr = expression as BinaryExpression;
if (binaryExpr != null && binaryExpr.NodeType == ExpressionType.OrElse)
{
// Split the OR condition into separate expressions
var left = binaryExpr.Left;
var right = binaryExpr.Right;
// Process left and right expressions recursively
CollectBinaryExpressions(left, predicate, jsonQueries);
CollectBinaryExpressions(right, predicate, jsonQueries);
}
else
{
// If the expression is a single condition, create a query for it
var test = expression.ToString();
var tes2t = predicate.ToString();
string jsonQuery = GetJsonQueryFromExpression(Expression.Lambda<Func<T, bool>>(expression, predicate.Parameters));
jsonQueries.Add(jsonQuery);
}
}
private object ConvertValueToType(object value, Type targetType)
{
if (targetType == typeof(Guid) && value is string stringValue)
{
return Guid.Parse(stringValue);
}
return Convert.ChangeType(value, targetType);
}
private IList<TRecord> ConvertListToRecords<TRecord>(IList<Dictionary<string, object>> listToConvert, Dictionary<string, string> propertyMappings)
{
var records = new List<TRecord>();
var recordType = typeof(TRecord);
foreach (var item in listToConvert)
{
var record = Activator.CreateInstance<TRecord>();
foreach (var kvp in item)
{
if (propertyMappings.TryGetValue(kvp.Key, out var propertyName))
{
var property = recordType.GetProperty(propertyName);
var value = ManagerHelper.GetValueFromValueKind(kvp.Value);
if (property != null)
{
property.SetValue(record, ConvertValueToType(value!, property.PropertyType));
}
}
}
records.Add(record);
}
return records;
}
private TRecord ConvertIndexedDbRecordToCRecord<TRecord>(Dictionary<string, object> item, Dictionary<string, string> propertyMappings)
{
var recordType = typeof(TRecord);
var record = Activator.CreateInstance<TRecord>();
foreach (var kvp in item)
{
if (propertyMappings.TryGetValue(kvp.Key, out var propertyName))
{
var property = recordType.GetProperty(propertyName);
var value = ManagerHelper.GetValueFromValueKind(kvp.Value);
if (property != null)
{
property.SetValue(record, ConvertValueToType(value!, property.PropertyType));
}
}
}
return record;
}
private string GetJsonQueryFromExpression<T>(Expression<Func<T, bool>> predicate) where T : class
{
var serializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
var conditions = new List<JObject>();
var orConditions = new List<List<JObject>>();
void TraverseExpression(Expression expression, bool inOrBranch = false)
{
if (expression is BinaryExpression binaryExpression)
{
if (binaryExpression.NodeType == ExpressionType.AndAlso)
{
TraverseExpression(binaryExpression.Left, inOrBranch);
TraverseExpression(binaryExpression.Right, inOrBranch);
}
else if (binaryExpression.NodeType == ExpressionType.OrElse)
{
if (inOrBranch)
{
throw new InvalidOperationException("Nested OR conditions are not supported.");
}
TraverseExpression(binaryExpression.Left, !inOrBranch);
TraverseExpression(binaryExpression.Right, !inOrBranch);
}
else
{
AddCondition(binaryExpression, inOrBranch);
}
}
else if (expression is MethodCallExpression methodCallExpression)
{
AddCondition(methodCallExpression, inOrBranch);
}
}
void AddCondition(Expression expression, bool inOrBranch)
{
if (expression is BinaryExpression binaryExpression)
{
var leftMember = binaryExpression.Left as MemberExpression;
var rightMember = binaryExpression.Right as MemberExpression;
var leftConstant = binaryExpression.Left as ConstantExpression;
var rightConstant = binaryExpression.Right as ConstantExpression;
var operation = binaryExpression.NodeType.ToString();
if (leftMember != null && rightConstant != null)
{
AddConditionInternal(leftMember, rightConstant, operation, inOrBranch);
}
else if (leftConstant != null && rightMember != null)
{
// Swap the order of the left and right expressions and the operation
if (operation == "GreaterThan")
{
operation = "LessThan";
}
else if (operation == "LessThan")
{
operation = "GreaterThan";
}
else if (operation == "GreaterThanOrEqual")
{
operation = "LessThanOrEqual";
}
else if (operation == "LessThanOrEqual")
{
operation = "GreaterThanOrEqual";
}
AddConditionInternal(rightMember, leftConstant, operation, inOrBranch);
}
}
else if (expression is MethodCallExpression methodCallExpression)
{
if (methodCallExpression.Method.DeclaringType == typeof(string) &&
(methodCallExpression.Method.Name == "Equals" || methodCallExpression.Method.Name == "Contains" || methodCallExpression.Method.Name == "StartsWith"))
{
var left = methodCallExpression.Object as MemberExpression;
var right = methodCallExpression.Arguments[0] as ConstantExpression;
var operation = methodCallExpression.Method.Name;
var caseSensitive = true;
if (methodCallExpression.Arguments.Count > 1)
{
var stringComparison = methodCallExpression.Arguments[1] as ConstantExpression;
if (stringComparison != null && stringComparison.Value is StringComparison comparisonValue)
{
caseSensitive = comparisonValue == StringComparison.Ordinal || comparisonValue == StringComparison.CurrentCulture;
}
}
AddConditionInternal(left, right, operation == "Equals" ? "StringEquals" : operation, inOrBranch, caseSensitive);
}
}
}
void AddConditionInternal(MemberExpression? left, ConstantExpression? right, string operation, bool inOrBranch, bool caseSensitive = false)
{
if (left != null && right != null)
{
var propertyInfo = typeof(T).GetProperty(left.Member.Name);
if (propertyInfo != null)
{
bool index = propertyInfo.GetCustomAttributes(typeof(MagicIndexAttribute), false).Length == 0;
bool unique = propertyInfo.GetCustomAttributes(typeof(MagicUniqueIndexAttribute), false).Length == 0;
bool primary = propertyInfo.GetCustomAttributes(typeof(MagicPrimaryKeyAttribute), false).Length == 0;
if (index == true && unique == true && primary == true)
{
throw new InvalidOperationException($"Property '{propertyInfo.Name}' does not have the IndexDbAttribute.");
}
string? columnName = null;
if (index == false)
columnName = propertyInfo.GetPropertyColumnName<MagicIndexAttribute>();
else if (unique == false)
columnName = propertyInfo.GetPropertyColumnName<MagicUniqueIndexAttribute>();
else if (primary == false)
columnName = propertyInfo.GetPropertyColumnName<MagicPrimaryKeyAttribute>();
bool _isString = false;
JToken? valSend = null;
if (right != null && right.Value != null)
{
valSend = JToken.FromObject(right.Value);
_isString = right.Value is string;
}
var jsonCondition = new JObject
{
{ "property", columnName },
{ "operation", operation },
{ "value", valSend },
{ "isString", _isString },
{ "caseSensitive", caseSensitive }
};
if (inOrBranch)
{
var currentOrConditions = orConditions.LastOrDefault();
if (currentOrConditions == null)
{
currentOrConditions = new List<JObject>();
orConditions.Add(currentOrConditions);
}
currentOrConditions.Add(jsonCondition);
}
else
{
conditions.Add(jsonCondition);
}
}
}
}
TraverseExpression(predicate.Body);
if (conditions.Any())
{
orConditions.Add(conditions);
}
return JsonConvert.SerializeObject(orConditions, serializerSettings);
}
public class QuotaUsage
{
public long quota { get; set; }
public long usage { get; set; }
}
/// <summary>
/// Returns Mb
/// </summary>
/// <returns></returns>
public async Task<(double quota, double usage)> GetStorageEstimateAsync()
{
var storageInfo = await CallJavascriptNoTransaction<QuotaUsage>(IndexedDbFunctions.GET_STORAGE_ESTIMATE);
double quotaInMB = ConvertBytesToMegabytes(storageInfo.quota);
double usageInMB = ConvertBytesToMegabytes(storageInfo.usage);
return (quotaInMB, usageInMB);
}
private static double ConvertBytesToMegabytes(long bytes)
{
return (double)bytes / (1024 * 1024);
}
public async Task<IEnumerable<T>> GetAll<T>() where T : class
{
var trans = GenerateTransaction(null);
try
{
string schemaName = SchemaHelper.GetSchemaName<T>();
var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
IList<Dictionary<string, object>>? ListToConvert = await CallJavascript<IList<Dictionary<string, object>>>(IndexedDbFunctions.TOARRAY, trans, DbName, schemaName);
var resultList = ConvertListToRecords<T>(ListToConvert, propertyMappings);
return resultList;
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return Enumerable.Empty<T>();
}
public async Task<Guid> Delete<T>(T item, Action<BlazorDbEvent>? action = null) where T : class
{
var trans = GenerateTransaction(action);
try
{
string schemaName = SchemaHelper.GetSchemaName<T>();
PropertyInfo? primaryKeyProperty = typeof(T).GetProperties().FirstOrDefault(prop => Attribute.IsDefined(prop, typeof(MagicPrimaryKeyAttribute)));
if (primaryKeyProperty != null)
{
object? primaryKeyValue = primaryKeyProperty.GetValue(item);
var convertedRecord = ManagerHelper.ConvertRecordToDictionary(item);
if (primaryKeyValue != null)
{
UpdateRecord<Dictionary<string, object?>> record = new UpdateRecord<Dictionary<string, object?>>()
{
Key = primaryKeyValue,
DbName = this.DbName,
StoreName = schemaName,
Record = convertedRecord
};
// Get the primary key value of the item
await CallJavascriptVoid(IndexedDbFunctions.DELETE_ITEM, trans, record);
}
else
{
throw new ArgumentException("Item being Deleted must have a key.");
}
}
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return trans;
}
public async Task<int> DeleteRange<TResult>(IEnumerable<TResult> items) where TResult : class
{
List<object> keys = new List<object>();
foreach (var item in items)
{
PropertyInfo? primaryKeyProperty = typeof(TResult).GetProperties().FirstOrDefault(prop => Attribute.IsDefined(prop, typeof(MagicPrimaryKeyAttribute)));
if (primaryKeyProperty == null)
{
throw new InvalidOperationException("No primary key property found with PrimaryKeyDbAttribute.");
}
object? primaryKeyValue = primaryKeyProperty.GetValue(item);
if (primaryKeyValue != null)
keys.Add(primaryKeyValue);
}
string schemaName = SchemaHelper.GetSchemaName<TResult>();
var trans = GenerateTransaction(null);
var data = new { DbName = DbName, StoreName = schemaName, Keys = keys };
try
{
var deletedCount = await CallJavascript<int>(IndexedDbFunctions.BULK_DELETE, trans, data.DbName, data.StoreName, data.Keys);
return deletedCount;
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return 0;
}
/// <summary>
/// Clears all data from a Table but keeps the table
/// </summary>
/// <param name="storeName"></param>
/// <param name="action"></param>
/// <returns></returns>
public async Task<Guid> ClearTable(string storeName, Action<BlazorDbEvent>? action = null)
{
var trans = GenerateTransaction(action);
try
{
await CallJavascriptVoid(IndexedDbFunctions.CLEAR_TABLE, trans, DbName, storeName);
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return trans;
}
public async Task<Guid> ClearTable<T>(Action<BlazorDbEvent>? action = null) where T : class
{
var trans = GenerateTransaction(action);
try
{
string schemaName = SchemaHelper.GetSchemaName<T>();
await CallJavascriptVoid(IndexedDbFunctions.CLEAR_TABLE, trans, DbName, schemaName);
}
catch (JSException jse)
{
RaiseEvent(trans, true, jse.Message);
}
return trans;
}
/// <summary>
/// Clears all data from a Table but keeps the table
/// Wait for response
/// </summary>
/// <param name="storeName"></param>
/// <returns></returns>
public async Task<BlazorDbEvent> ClearTableAsync(string storeName)
{
var trans = GenerateTransaction();
try
{
await CallJavascriptVoid(IndexedDbFunctions.CLEAR_TABLE, trans.trans, DbName, storeName);
}
catch (JSException jse)
{
RaiseEvent(trans.trans, true, jse.Message);
}
return await trans.task;
}
[JSInvokable("BlazorDBCallback")]
public void CalledFromJS(Guid transaction, bool failed, string message)
{
if (transaction != Guid.Empty)
{
WeakReference<Action<BlazorDbEvent>>? r = null;
_transactions.TryGetValue(transaction, out r);
TaskCompletionSource<BlazorDbEvent>? t = null;
_taskTransactions.TryGetValue(transaction, out t);
if (r != null && r.TryGetTarget(out Action<BlazorDbEvent>? action))
{
action?.Invoke(new BlazorDbEvent()
{
Transaction = transaction,
Message = message,
Failed = failed
});
_transactions.Remove(transaction);
}
else if (t != null)
{
t.TrySetResult(new BlazorDbEvent()
{
Transaction = transaction,
Message = message,
Failed = failed
});
_taskTransactions.Remove(transaction);
}
else
RaiseEvent(transaction, failed, message);
}
}
//async Task<TResult> CallJavascriptNoTransaction<TResult>(string functionName, params object[] args)
//{
// return await _jsRuntime.InvokeAsync<TResult>($"{InteropPrefix}.{functionName}", args);
//}
async Task<TResult> CallJavascriptNoTransaction<TResult>(string functionName, params object[] args)
{
var mod = await GetModule(_jsRuntime);
return await mod.InvokeAsync<TResult>($"{functionName}", args);
}
private const string dynamicJsCaller = "DynamicJsCaller";
/// <summary>
///
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="functionName"></param>
/// <param name="transaction"></param>
/// <param name="timeout">in ms</param>
/// <param name="args"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
public async Task<TResult> CallJS<TResult>(string functionName, double Timeout, params object[] args)
{
List<object> modifiedArgs = new List<object>(args);
modifiedArgs.Insert(0, $"{InteropPrefix}.{functionName}");
Task<JsResponse<TResult>> task = _jsRuntime.InvokeAsync<JsResponse<TResult>>(dynamicJsCaller, modifiedArgs.ToArray()).AsTask();
Task delay = Task.Delay(TimeSpan.FromMilliseconds(Timeout));
if (await Task.WhenAny(task, delay) == task)
{
JsResponse<TResult> response = await task;
if (response.Success)
return response.Data;
else
throw new ArgumentException(response.Message);
}
else
{
throw new ArgumentException("Timed out after 1 minute");
}
}
//public async Task<TResult> CallJS<TResult>(string functionName, JsSettings Settings, params object[] args)
//{
// var newArgs = GetNewArgs(Settings.Transaction, args);
// Task<JsResponse<TResult>> task = _jsRuntime.InvokeAsync<JsResponse<TResult>>($"{InteropPrefix}.{functionName}", newArgs).AsTask();
// Task delay = Task.Delay(TimeSpan.FromMilliseconds(Settings.Timeout));
// if (await Task.WhenAny(task, delay) == task)
// {
// JsResponse<TResult> response = await task;
// if (response.Success)
// return response.Data;
// else
// throw new ArgumentException(response.Message);
// }
// else
// {
// throw new ArgumentException("Timed out after 1 minute");
// }
//}
//async Task<TResult> CallJavascript<TResult>(string functionName, Guid transaction, params object[] args)
//{
// var newArgs = GetNewArgs(transaction, args);
// return await _jsRuntime.InvokeAsync<TResult>($"{InteropPrefix}.{functionName}", newArgs);
//}
//async Task CallJavascriptVoid(string functionName, Guid transaction, params object[] args)
//{
// var newArgs = GetNewArgs(transaction, args);
// await _jsRuntime.InvokeVoidAsync($"{InteropPrefix}.{functionName}", newArgs);
//}
async Task<TResult> CallJavascript<TResult>(string functionName, Guid transaction, params object[] args)
{
var mod = await GetModule(_jsRuntime);
var newArgs = GetNewArgs(transaction, args);
return await mod.InvokeAsync<TResult>($"{functionName}", newArgs);
}
async Task CallJavascriptVoid(string functionName, Guid transaction, params object[] args)
{
var mod = await GetModule(_jsRuntime);
var newArgs = GetNewArgs(transaction, args);
await mod.InvokeVoidAsync($"{functionName}", newArgs);
}
object[] GetNewArgs(Guid transaction, params object[] args)
{
var newArgs = new object[args.Length + 2];
newArgs[0] = _objReference;
newArgs[1] = transaction;
for (var i = 0; i < args.Length; i++)
newArgs[i + 2] = args[i];
return newArgs;
}
(Guid trans, Task<BlazorDbEvent> task) GenerateTransaction()
{
bool generated = false;
var transaction = Guid.Empty;
TaskCompletionSource<BlazorDbEvent> tcs = new TaskCompletionSource<BlazorDbEvent>();
do
{
transaction = Guid.NewGuid();
if (!_taskTransactions.ContainsKey(transaction))
{
generated = true;
_taskTransactions.Add(transaction, tcs);
}
} while (!generated);
return (transaction, tcs.Task);
}
Guid GenerateTransaction(Action<BlazorDbEvent>? action)
{
bool generated = false;
Guid transaction = Guid.Empty;
do
{
transaction = Guid.NewGuid();
if (!_transactions.ContainsKey(transaction))
{
generated = true;
_transactions.Add(transaction, new WeakReference<Action<BlazorDbEvent>>(action!));
}
} while (!generated);
return transaction;
}
void RaiseEvent(Guid transaction, bool failed, string message)
=> ActionCompleted?.Invoke(this, new BlazorDbEvent { Transaction = transaction, Failed = failed, Message = message });
}
}
| Magic.IndexedDb/IndexDbManager.cs | magiccodingman-Magic.IndexedDb-a279d6d | [
{
"filename": "Magic.IndexedDb/Factories/MagicDbFactory.cs",
"retrieved_chunk": " readonly IJSRuntime _jsRuntime;\n readonly IServiceProvider _serviceProvider;\n readonly IDictionary<string, IndexedDbManager> _dbs = new Dictionary<string, IndexedDbManager>();\n //private IJSObjectReference _module;\n public MagicDbFactory(IServiceProvider serviceProvider, IJSRuntime jSRuntime)\n {\n _serviceProvider = serviceProvider;\n _jsRuntime = jSRuntime;\n }\n //public async Task<IndexedDbManager> CreateAsync(DbStore dbStore)",
"score": 0.7849578857421875
},
{
"filename": "Magic.IndexedDb/Factories/IMagicDbFactory.cs",
"retrieved_chunk": "using System.Threading.Tasks;\nnamespace Magic.IndexedDb\n{\n public interface IMagicDbFactory\n {\n Task<IndexedDbManager> GetDbManager(string dbName);\n Task<IndexedDbManager> GetDbManager(DbStore dbStore);\n }\n}",
"score": 0.7705756425857544
},
{
"filename": "Magic.IndexedDb/Extensions/ServiceCollectionExtensions.cs",
"retrieved_chunk": " {\n public static IServiceCollection AddBlazorDB(this IServiceCollection services, Action<DbStore> options)\n {\n var dbStore = new DbStore();\n options(dbStore);\n services.AddTransient<DbStore>((_) => dbStore);\n services.TryAddSingleton<IMagicDbFactory, MagicDbFactory>();\n return services;\n }\n public static IServiceCollection AddEncryptionFactory(this IServiceCollection services)",
"score": 0.7421634793281555
},
{
"filename": "Magic.IndexedDb/Factories/MagicDbFactory.cs",
"retrieved_chunk": " //{\n // var manager = new IndexedDbManager(dbStore, _jsRuntime);\n // var importedManager = await _jsRuntime.InvokeAsync<IJSObjectReference>(\"import\", \"./_content/Magic.IndexedDb/magicDB.js\");\n // return manager;\n //}\n public async Task<IndexedDbManager> GetDbManager(string dbName)\n {\n if (!_dbs.Any())\n await BuildFromServices();\n if (_dbs.ContainsKey(dbName))",
"score": 0.731208086013794
},
{
"filename": "Magic.IndexedDb/Models/BlazorEvent.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\nnamespace Magic.IndexedDb\n{\n public class BlazorDbEvent\n {\n public Guid Transaction { get; set; }",
"score": 0.6982718706130981
}
] | csharp | BlazorDbEvent> ActionCompleted; |
using EF012.CodeFirstMigration.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
namespace EF012.CodeFirstMigration.Data
{
public class AppDbContext : DbContext
{
public DbSet<Course> Courses { get; set; }
public DbSet<Instructor> Instructors { get; set; }
public DbSet< | Office> Offices { | get; set; }
public DbSet<Section> Sections { get; set; }
public DbSet<Schedule> Schedules { get; set; }
public DbSet<Student> Students { get; set; }
public DbSet<Enrollment> Enrollments { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
var config = new ConfigurationBuilder().AddJsonFile("appsettings.json")
.Build();
var connectionString = config.GetSection("constr").Value;
optionsBuilder.UseSqlServer(connectionString);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
// modelBuilder.ApplyConfiguration(new CourseConfiguration()); // not best practice
modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);
}
}
}
| EF012.CodeFirstMigration/Data/AppDbContext.cs | metigator-EF012-054d65d | [
{
"filename": "EF012.CodeFirstMigration/Program.cs",
"retrieved_chunk": "using EF012.CodeFirstMigration.Data;\nusing Microsoft.EntityFrameworkCore;\nnamespace EF012.CodeFirstMigration\n{\n class Program\n {\n public static void Main(string[] args)\n {\n using (var context = new AppDbContext())\n {",
"score": 0.8480002880096436
},
{
"filename": "EF012.CodeFirstMigration/Entities/Course.cs",
"retrieved_chunk": "namespace EF012.CodeFirstMigration.Entities\n{\n public class Course\n {\n public int Id { get; set; }\n public string? CourseName { get; set; }\n public decimal Price { get; set; }\n public ICollection<Section> Sections { get; set; } = new List<Section>();\n }\n}",
"score": 0.8464978933334351
},
{
"filename": "EF012.CodeFirstMigration/Entities/Office.cs",
"retrieved_chunk": "namespace EF012.CodeFirstMigration.Entities\n{\n public class Office\n {\n public int Id { get; set; }\n public string? OfficeName { get; set; }\n public string? OfficeLocation { get; set; }\n public Instructor? Instructor { get; set; }\n }\n}",
"score": 0.839759349822998
},
{
"filename": "EF012.CodeFirstMigration/Entities/Instructor.cs",
"retrieved_chunk": "namespace EF012.CodeFirstMigration.Entities\n{\n public class Instructor\n {\n public int Id { get; set; }\n public string? FName { get; set; }\n public string? LName { get; set; }\n public int? OfficeId { get; set; }\n public Office? Office { get; set; }\n public ICollection<Section> Sections { get; set; } = new List<Section>();",
"score": 0.8383657336235046
},
{
"filename": "EF012.CodeFirstMigration/Entities/Student.cs",
"retrieved_chunk": "namespace EF012.CodeFirstMigration.Entities\n{\n public class Student\n {\n public int Id { get; set; }\n public string? FName { get; set; }\n public string? LName { get; set; }\n public ICollection<Section> Sections { get; set; } = new List<Section>();\n }\n}",
"score": 0.8315902948379517
}
] | csharp | Office> Offices { |
using System;
namespace it
{
using it.Actions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Win32;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Web.Services.Description;
using System.Windows;
using System.Windows.Forms;
/// <summary>
/// The bootstrap class is provided to allow the application to run with out a form. We can use
/// a form however in the future by adding it to here.
/// </summary>
internal sealed class Bootstrap : IDisposable
{
private readonly ClipboardMonitor clipboardMonitor = new ClipboardMonitor();
private readonly ControlContainer container = new ControlContainer();
private readonly NotifyIcon notifyIcon;
private readonly List< | Question> questionList = Questions.LoadQuestions(); |
private bool clipboardPaused = false;
private bool disposed = false;
private IntPtr handle;
private bool notifyPaused = false;
// Container to hold the actions
private ServiceProvider serviceProvider;
public Bootstrap()
{
notifyIcon = new NotifyIcon(container)
{
Visible = true,
};
ConfigureDependancies();
clipboardMonitor.ClipboardChanged += ClipboardMonitor_ClipboardChanged;
}
~Bootstrap()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
internal static void EnsureWindowStartup(bool isStartingWithWindows)
{
const string keyName = "Clipboard Assistant";
using (
RegistryKey key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true))
{
if (key is null)
{
return;
}
string value = key.GetValue(keyName, null) as string;
if (isStartingWithWindows)
{
// key doesn't exist, add it
if (string.IsNullOrWhiteSpace(value) && string.Equals(value, Assembly.GetExecutingAssembly().Location, StringComparison.Ordinal))
{
key.SetValue(keyName, Assembly.GetExecutingAssembly().Location);
}
}
else if (!string.IsNullOrWhiteSpace(value))
{
key.DeleteValue(keyName);
}
}
}
internal void Startup(string clipboardText)
{
}
[System.Runtime.InteropServices.DllImport("Kernel32")]
private static extern Boolean CloseHandle(IntPtr handle);
private static string GetClipboardText(string clipboardText)
{
return clipboardText;
}
private void ClipboardMonitor_ClipboardChanged(object sender, ClipboardChangedEventArgs e)
{
// retrieve the text from the clipboard
if (e.DataObject.GetData(System.Windows.DataFormats.Text) is string clipboardText)
{
// the data is not a string. bail.
if (string.IsNullOrWhiteSpace(clipboardText))
{
return;
}
if (clipboardPaused)
{
if (clipboardText.Equals("hervat") || clipboardText.Equals("resume"))
{
clipboardPaused = false;
}
return;
}
if (clipboardText.Equals("pauze") || clipboardText.Equals("pause"))
{
clipboardPaused = true;
return;
}
// if we get to here, we have text
ProcessClipboardText(clipboardText);
}
}
private void ConfigureDependancies()
{
// Add configure services
Microsoft.Extensions.DependencyInjection.ServiceCollection serviceDescriptors = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
_ = serviceDescriptors.AddSingleton<IAction, CurrencyConversion>();
_ = serviceDescriptors.AddSingleton<IAction, ConvertActions>();
_ = serviceDescriptors.AddSingleton<IAction, TryRomanActions>();
_ = serviceDescriptors.AddSingleton<IAction, CountdownActions>();
_ = serviceDescriptors.AddSingleton<IAction, DeviceActions>();
_ = serviceDescriptors.AddSingleton<IAction, RandomActions>();
_ = serviceDescriptors.AddSingleton<IAction, StopwatchActions>();
_ = serviceDescriptors.AddSingleton<IAction, TimespanActions>();
_ = serviceDescriptors.AddSingleton<IAction, numberToHex>();
_ = serviceDescriptors.AddSingleton<IAction, desktopCleaner>();
_ = serviceDescriptors.AddSingleton<IAction, TimezoneActions>();
_ = serviceDescriptors.AddSingleton<IAction, BmiActions>();
_ = serviceDescriptors.AddSingleton<IAction, tryBinary>();
_ = serviceDescriptors.AddSingleton<IAction, Currency>();
_ = serviceDescriptors.AddSingleton<IAction, Wallpaper>();
_ = serviceDescriptors.AddSingleton<IAction, autoClicker>();
_ = serviceDescriptors.AddSingleton<IAction, timeCalculations>();
//_ = serviceDescriptors.AddSingleton<IAction, Weatherforecast>();
_ = serviceDescriptors.AddSingleton<IAction, MathActions>();
(serviceProvider as IDisposable)?.Dispose();
serviceProvider = serviceDescriptors.BuildServiceProvider();
}
private void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
(serviceProvider as IDisposable)?.Dispose();
notifyIcon?.Dispose();
notifyIcon.Icon?.Dispose();
container?.Dispose();
clipboardMonitor?.Dispose();
}
CloseHandle(handle);
handle = IntPtr.Zero;
disposed = true;
}
private IAction GetService(string clipboardText)
{
return serviceProvider.GetServices<IAction>().FirstOrDefault(s => s.Matches(GetClipboardText(clipboardText)));
}
private void ProcessClipboardText(string clipboardText)
{
if (clipboardText is null)
{
throw new ArgumentNullException(nameof(clipboardText));
}
if (notifyPaused)
{
if (clipboardText.Equals("show notifications") || clipboardText.Equals("toon notificaties") || clipboardText.Equals("toon") || clipboardText.Equals("show"))
{
notifyPaused = false;
}
return;
}
if (clipboardText.Equals("hide notifications") || clipboardText.Equals("verberg notificaties") || clipboardText.Equals("verberg") || clipboardText.Equals("hide"))
{
notifyPaused = true;
}
try
{
IAction service = GetService(clipboardText);
if (service is object)
{
clipboardMonitor.ClipboardChanged -= ClipboardMonitor_ClipboardChanged;
ActionResult actionResult = service.TryExecute(clipboardText);
clipboardMonitor.ClipboardChanged += ClipboardMonitor_ClipboardChanged;
// re attach the event
if (!string.IsNullOrWhiteSpace(actionResult.Title) || !string.IsNullOrWhiteSpace(actionResult.Description))
{
ProcessResult(actionResult, clipboardText);
}
return;
}
if (clipboardText.Length > 2)
{
{
for (int i = 0; i < questionList.Count; i++)
{
Question question = questionList[i];
if (question.Text.Contains(clipboardText))
{
ProcessResult(new ActionResult(question.Text, question.Answer), clipboardText);
return;
}
}
}
}
}
catch (Exception ex)
{
_ = System.Windows.Forms.MessageBox.Show(ex.ToString());
}
}
private void ProcessResult(ActionResult actionResult, string clipboardText)
{
notifyIcon.Icon = SystemIcons.Exclamation;
notifyIcon.BalloonTipTitle = actionResult.Title;
notifyIcon.BalloonTipText = actionResult.Description;
notifyIcon.BalloonTipIcon = ToolTipIcon.Error;
if (!notifyPaused)
{
notifyIcon.ShowBalloonTip(1000);
}
}
}
}
| Bootstrap.cs | Teun-vdB-NotifySolver-88c06a6 | [
{
"filename": "ClipboardMonitor.cs",
"retrieved_chunk": " DataObject = dataObject;\n }\n public IDataObject DataObject { get; }\n }\n [DefaultEvent(\"ClipboardChanged\")]\n internal sealed class ClipboardMonitor : Control\n {\n private IntPtr NextViewerPtr;\n public ClipboardMonitor()\n {",
"score": 0.8507025241851807
},
{
"filename": "IAction.cs",
"retrieved_chunk": " ActionResult TryExecute(string clipboardText = null);\n bool Matches(string clipboardText = null);\n }\n internal abstract class ActionBase : IAction, IEquatable<ActionBase>\n {\n public bool Equals(ActionBase other)\n {\n throw new NotImplementedException();\n }\n public abstract bool Matches(string clipboardText = null);",
"score": 0.8499308824539185
},
{
"filename": "Actions/IAction.cs",
"retrieved_chunk": " PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));\n }\n }\n internal abstract class ActionBase : IAction, IEquatable<ActionBase>\n {\n public bool Equals(ActionBase other)\n {\n throw new NotImplementedException();\n }\n public abstract bool Matches(string clipboardText = null);",
"score": 0.8484028577804565
},
{
"filename": "IAction.cs",
"retrieved_chunk": " Description = description;\n }\n public event PropertyChangedEventHandler PropertyChanged;\n internal string Description { get; set; }\n internal string Title { get; set; }\n public bool Equals(ActionResult other)\n {\n throw new NotImplementedException();\n }\n public override bool Equals(object obj)",
"score": 0.8371505737304688
},
{
"filename": "Actions/StopwatchActions.cs",
"retrieved_chunk": " }\n public bool Matches(string clipboardText)\n {\n return clipboardText.IndexOf(nameof(stopwatch), StringComparison.Ordinal) >= 0;\n }\n public ActionResult TryExecute(string clipboardText)\n {\n ActionResult actionResult = new ActionResult(\"Stopwatch\");\n CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;\n // moved this from every case statement to up here. Not sure what to do if the clipboard",
"score": 0.8275144100189209
}
] | csharp | Question> questionList = Questions.LoadQuestions(); |
using System.Diagnostics;
using Gum.Utilities;
namespace Gum.InnerThoughts
{
[DebuggerDisplay("{DebuggerDisplay(),nq}")]
public readonly struct CriterionNode
{
public readonly Criterion Criterion = new();
public readonly CriterionNodeKind Kind = CriterionNodeKind.And;
public CriterionNode() { }
public CriterionNode(Criterion criterion) =>
Criterion = criterion;
public CriterionNode( | Criterion criterion, CriterionNodeKind kind) =>
(Criterion, Kind) = (criterion, kind); |
public CriterionNode WithCriterion(Criterion criterion) => new(criterion, Kind);
public CriterionNode WithKind(CriterionNodeKind kind) => new(Criterion, kind);
public string DebuggerDisplay()
{
return $"{OutputHelpers.ToCustomString(Kind)} {Criterion.DebuggerDisplay()}";
}
}
}
| src/Gum/InnerThoughts/CriterionNode.cs | isadorasophia-gum-032cb2d | [
{
"filename": "src/Gum/InnerThoughts/Criterion.cs",
"retrieved_chunk": " /// </summary>\n public static Criterion Component => new(Fact.Component, CriterionKind.Is, true);\n public Criterion(Fact fact, CriterionKind kind, object @value)\n {\n bool? @bool = null;\n int? @int = null;\n string? @string = null;\n // Do not propagate previous values.\n switch (fact.Kind)\n {",
"score": 0.8599523305892944
},
{
"filename": "src/Gum/InnerThoughts/Criterion.cs",
"retrieved_chunk": " public readonly string? StrValue = null;\n public readonly int? IntValue = null;\n public readonly bool? BoolValue = null;\n public Criterion() { }\n /// <summary>\n /// Creates a fact of type <see cref=\"FactKind.Weight\"/>.\n /// </summary>\n public static Criterion Weight => new(Fact.Weight, CriterionKind.Is, 1);\n /// <summary>\n /// Creates a fact of type <see cref=\"FactKind.Component\"/>.",
"score": 0.8365737199783325
},
{
"filename": "src/Gum/InnerThoughts/Criterion.cs",
"retrieved_chunk": "using System.Text;\nusing System.Diagnostics;\nusing Gum.Utilities;\nnamespace Gum.InnerThoughts\n{\n [DebuggerDisplay(\"{DebuggerDisplay(),nq}\")]\n public readonly struct Criterion\n {\n public readonly Fact Fact = new();\n public readonly CriterionKind Kind = CriterionKind.Is;",
"score": 0.8049319982528687
},
{
"filename": "src/Gum/Parser_Requirements.cs",
"retrieved_chunk": " break;\n case Tokens.And:\n case Tokens.And2:\n nodeKind = CriterionNodeKind.And;\n break;\n // TODO: Check for '...'\n }\n ReadOnlySpan<char> variableToken = token;\n if (nodeKind is not null)\n {",
"score": 0.7894978523254395
},
{
"filename": "src/Gum/Parser_Requirements.cs",
"retrieved_chunk": " return true;\n }\n // Diagnostics... 🙏\n currentColumn += token.Length;\n CriterionNodeKind? nodeKind = null;\n switch (token)\n {\n case Tokens.Or:\n case Tokens.Or2:\n nodeKind = CriterionNodeKind.Or;",
"score": 0.7894060015678406
}
] | csharp | Criterion criterion, CriterionNodeKind kind) =>
(Criterion, Kind) = (criterion, kind); |
using BepInEx;
using UnityEngine;
using UnityEngine.SceneManagement;
using System;
using HarmonyLib;
using System.IO;
using Ultrapain.Patches;
using System.Linq;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Reflection;
using Steamworks;
using Unity.Audio;
using System.Text;
using System.Collections.Generic;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.UIElements;
using PluginConfig.API;
namespace Ultrapain
{
[BepInPlugin(PLUGIN_GUID, PLUGIN_NAME, PLUGIN_VERSION)]
[BepInDependency("com.eternalUnion.pluginConfigurator", "1.6.0")]
public class Plugin : BaseUnityPlugin
{
public const string PLUGIN_GUID = "com.eternalUnion.ultraPain";
public const string PLUGIN_NAME = "Ultra Pain";
public const string PLUGIN_VERSION = "1.1.0";
public static Plugin instance;
private static bool addressableInit = false;
public static T LoadObject<T>(string path)
{
if (!addressableInit)
{
Addressables.InitializeAsync().WaitForCompletion();
addressableInit = true;
}
return Addressables.LoadAssetAsync<T>(path).WaitForCompletion();
}
public static Vector3 PredictPlayerPosition(Collider safeCollider, float speedMod)
{
Transform target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
return target.position;
RaycastHit raycastHit;
if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == safeCollider)
return target.position;
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
return raycastHit.point;
}
else {
Vector3 projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
return new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
}
public static GameObject projectileSpread;
public static GameObject homingProjectile;
public static GameObject hideousMassProjectile;
public static GameObject decorativeProjectile2;
public static GameObject shotgunGrenade;
public static GameObject beam;
public static GameObject turretBeam;
public static GameObject lightningStrikeExplosiveSetup;
public static GameObject lightningStrikeExplosive;
public static GameObject lighningStrikeWindup;
public static GameObject explosion;
public static GameObject bigExplosion;
public static GameObject sandExplosion;
public static GameObject virtueInsignia;
public static GameObject rocket;
public static GameObject revolverBullet;
public static GameObject maliciousCannonBeam;
public static GameObject lightningBoltSFX;
public static GameObject revolverBeam;
public static GameObject blastwave;
public static GameObject cannonBall;
public static GameObject shockwave;
public static GameObject sisyphiusExplosion;
public static GameObject sisyphiusPrimeExplosion;
public static GameObject explosionWaveKnuckleblaster;
public static GameObject chargeEffect;
public static GameObject maliciousFaceProjectile;
public static GameObject hideousMassSpear;
public static GameObject coin;
public static GameObject sisyphusDestroyExplosion;
//public static GameObject idol;
public static GameObject ferryman;
public static GameObject minosPrime;
//public static GameObject maliciousFace;
public static GameObject somethingWicked;
public static Turret turret;
public static GameObject turretFinalFlash;
public static GameObject enrageEffect;
public static GameObject v2flashUnparryable;
public static GameObject ricochetSfx;
public static GameObject parryableFlash;
public static AudioClip cannonBallChargeAudio;
public static Material gabrielFakeMat;
public static Sprite blueRevolverSprite;
public static | Sprite greenRevolverSprite; |
public static Sprite redRevolverSprite;
public static Sprite blueShotgunSprite;
public static Sprite greenShotgunSprite;
public static Sprite blueNailgunSprite;
public static Sprite greenNailgunSprite;
public static Sprite blueSawLauncherSprite;
public static Sprite greenSawLauncherSprite;
public static GameObject rocketLauncherAlt;
public static GameObject maliciousRailcannon;
// Variables
public static float SoliderShootAnimationStart = 1.2f;
public static float SoliderGrenadeForce = 10000f;
public static float SwordsMachineKnockdownTimeNormalized = 0.8f;
public static float SwordsMachineCoreSpeed = 80f;
public static float MinGrenadeParryVelocity = 40f;
public static GameObject _lighningBoltSFX;
public static GameObject lighningBoltSFX
{
get
{
if (_lighningBoltSFX == null)
_lighningBoltSFX = ferryman.gameObject.transform.Find("LightningBoltChimes").gameObject;
return _lighningBoltSFX;
}
}
private static bool loadedPrefabs = false;
public void LoadPrefabs()
{
if (loadedPrefabs)
return;
loadedPrefabs = true;
// Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab
projectileSpread = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab
homingProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab
decorativeProjectile2 = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab");
// Assets/Prefabs/Attacks and Projectiles/Grenade.prefab
shotgunGrenade = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Grenade.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab
turretBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
beam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab
lightningStrikeExplosiveSetup = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab");
// Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab
lighningStrikeWindup = LoadObject<GameObject>("Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab");
//[bundle-0][assets/prefabs/enemies/idol.prefab]
//idol = LoadObject<GameObject>("assets/prefabs/enemies/idol.prefab");
// Assets/Prefabs/Enemies/Ferryman.prefab
ferryman = LoadObject<GameObject>("Assets/Prefabs/Enemies/Ferryman.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab
explosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab
bigExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab
sandExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab");
// Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab
virtueInsignia = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab
hideousMassProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab");
// Assets/Particles/Enemies/RageEffect.prefab
enrageEffect = LoadObject<GameObject>("Assets/Particles/Enemies/RageEffect.prefab");
// Assets/Particles/Flashes/V2FlashUnparriable.prefab
v2flashUnparryable = LoadObject<GameObject>("Assets/Particles/Flashes/V2FlashUnparriable.prefab");
// Assets/Prefabs/Attacks and Projectiles/Rocket.prefab
rocket = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Rocket.prefab");
// Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab
revolverBullet = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab
maliciousCannonBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab
revolverBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab
blastwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab");
// Assets/Prefabs/Enemies/MinosPrime.prefab
minosPrime = LoadObject<GameObject>("Assets/Prefabs/Enemies/MinosPrime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab
cannonBall = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab");
// get from Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
cannonBallChargeAudio = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab").transform.Find("RocketLauncher/Armature/Body_Bone/HologramDisplay").GetComponent<AudioSource>().clip;
// Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab
shockwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab
sisyphiusExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab
sisyphiusPrimeExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab
explosionWaveKnuckleblaster = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab - [bundle-0][assets/prefabs/explosionlightning variant.prefab]
lightningStrikeExplosive = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab");
// Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
rocketLauncherAlt = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab");
// Assets/Prefabs/Weapons/Railcannon Malicious.prefab
maliciousRailcannon = LoadObject<GameObject>("Assets/Prefabs/Weapons/Railcannon Malicious.prefab");
//Assets/Particles/SoundBubbles/Ricochet.prefab
ricochetSfx = LoadObject<GameObject>("Assets/Particles/SoundBubbles/Ricochet.prefab");
//Assets/Particles/Flashes/Flash.prefab
parryableFlash = LoadObject<GameObject>("Assets/Particles/Flashes/Flash.prefab");
//Assets/Prefabs/Attacks and Projectiles/Spear.prefab
hideousMassSpear = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Spear.prefab");
//Assets/Prefabs/Enemies/Wicked.prefab
somethingWicked = LoadObject<GameObject>("Assets/Prefabs/Enemies/Wicked.prefab");
//Assets/Textures/UI/SingleRevolver.png
blueRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/SingleRevolver.png");
//Assets/Textures/UI/RevolverSpecial.png
greenRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSpecial.png");
//Assets/Textures/UI/RevolverSharp.png
redRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSharp.png");
//Assets/Textures/UI/Shotgun.png
blueShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun.png");
//Assets/Textures/UI/Shotgun1.png
greenShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun1.png");
//Assets/Textures/UI/Nailgun2.png
blueNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Nailgun2.png");
//Assets/Textures/UI/NailgunOverheat.png
greenNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/NailgunOverheat.png");
//Assets/Textures/UI/SawbladeLauncher.png
blueSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncher.png");
//Assets/Textures/UI/SawbladeLauncherOverheat.png
greenSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncherOverheat.png");
//Assets/Prefabs/Attacks and Projectiles/Coin.prefab
coin = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Coin.prefab");
//Assets/Materials/GabrielFake.mat
gabrielFakeMat = LoadObject<Material>("Assets/Materials/GabrielFake.mat");
//Assets/Prefabs/Enemies/Turret.prefab
turret = LoadObject<GameObject>("Assets/Prefabs/Enemies/Turret.prefab").GetComponent<Turret>();
//Assets/Particles/Flashes/GunFlashDistant.prefab
turretFinalFlash = LoadObject<GameObject>("Assets/Particles/Flashes/GunFlashDistant.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab
sisyphusDestroyExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab");
//Assets/Prefabs/Effects/Charge Effect.prefab
chargeEffect = LoadObject<GameObject>("Assets/Prefabs/Effects/Charge Effect.prefab");
//Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
maliciousFaceProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
}
public static bool ultrapainDifficulty = false;
public static bool realUltrapainDifficulty = false;
public static GameObject currentDifficultyButton;
public static GameObject currentDifficultyPanel;
public static Text currentDifficultyInfoText;
public void OnSceneChange(Scene before, Scene after)
{
StyleIDs.RegisterIDs();
ScenePatchCheck();
string mainMenuSceneName = "b3e7f2f8052488a45b35549efb98d902";
string bootSequenceSceneName = "4f8ecffaa98c2614f89922daf31fa22d";
string currentSceneName = SceneManager.GetActiveScene().name;
if (currentSceneName == mainMenuSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Difficulty Select (1)");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach(EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
else if(currentSceneName == bootSequenceSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Intro/Difficulty Select");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach (EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
// LOAD CUSTOM PREFABS HERE TO AVOID MID GAME LAG
MinosPrimeCharge.CreateDecoy();
GameObject shockwaveSisyphus = SisyphusInstructionist_Start.shockwave;
}
public static class StyleIDs
{
private static bool registered = false;
public static void RegisterIDs()
{
registered = false;
if (MonoSingleton<StyleHUD>.Instance == null)
return;
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.grenadeBoostStyleText.guid, ConfigManager.grenadeBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.rocketBoostStyleText.guid, ConfigManager.rocketBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverStyleText.guid, ConfigManager.orbStrikeRevolverStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverChargedStyleText.guid, ConfigManager.orbStrikeRevolverChargedStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeElectricCannonStyleText.guid, ConfigManager.orbStrikeElectricCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeMaliciousCannonStyleText.guid, ConfigManager.orbStrikeMaliciousCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.maliciousChargebackStyleText.guid, ConfigManager.maliciousChargebackStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.sentryChargebackStyleText.guid, ConfigManager.sentryChargebackStyleText.formattedString);
registered = true;
Debug.Log("Registered all style ids");
}
private static FieldInfo idNameDict = typeof(StyleHUD).GetField("idNameDict", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
public static void UpdateID(string id, string newName)
{
if (!registered || StyleHUD.Instance == null)
return;
(idNameDict.GetValue(StyleHUD.Instance) as Dictionary<string, string>)[id] = newName;
}
}
public static Harmony harmonyTweaks;
public static Harmony harmonyBase;
private static MethodInfo GetMethod<T>(string name)
{
return typeof(T).GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
private static Dictionary<MethodInfo, HarmonyMethod> methodCache = new Dictionary<MethodInfo, HarmonyMethod>();
private static HarmonyMethod GetHarmonyMethod(MethodInfo method)
{
if (methodCache.TryGetValue(method, out HarmonyMethod harmonyMethod))
return harmonyMethod;
else
{
harmonyMethod = new HarmonyMethod(method);
methodCache.Add(method, harmonyMethod);
return harmonyMethod;
}
}
private static void PatchAllEnemies()
{
if (!ConfigManager.enemyTweakToggle.value)
return;
if (ConfigManager.friendlyFireDamageOverrideToggle.value)
{
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<PhysicalShockwave>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<VirtueInsignia>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<Flammable>("Burn"), prefix: GetHarmonyMethod(GetMethod<Flammable_Burn_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<FireZone>("OnTriggerStay"), prefix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("UpdateModifiers"), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_UpdateModifiers>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Start"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Start_Patch>("Postfix")));
if (ConfigManager.cerberusDashToggle.value)
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopDash"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopDash_Patch>("Postfix")));
if(ConfigManager.cerberusParryable.value)
{
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopTracking"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopTracking_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Stomp"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Stomp_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Statue>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Statue_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Drone_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("Shoot"), prefix: GetHarmonyMethod(GetMethod<Drone_Shoot_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("PlaySound"), prefix: GetHarmonyMethod(GetMethod<Drone_PlaySound_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Update"), postfix: GetHarmonyMethod(GetMethod<Drone_Update>("Postfix")));
if(ConfigManager.droneHomeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Drone_Death_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Drone_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Ferryman>("Start"), postfix: GetHarmonyMethod(GetMethod<FerrymanStart>("Postfix")));
if(ConfigManager.ferrymanComboToggle.value)
harmonyTweaks.Patch(GetMethod<Ferryman>("StopMoving"), postfix: GetHarmonyMethod(GetMethod<FerrymanStopMoving>("Postfix")));
if(ConfigManager.filthExplodeToggle.value)
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch2>("Prefix")));
if(ConfigManager.fleshPrisonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<FleshPrisonShoot>("Postfix")));
if (ConfigManager.hideousMassInsigniaToggle.value)
{
harmonyTweaks.Patch(GetMethod<Projectile>("Explode"), postfix: GetHarmonyMethod(GetMethod<Projectile_Explode_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mass>("ShootExplosive"), postfix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Postfix")), prefix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<SpiderBody>("Start"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("ChargeBeam"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ChargeBeam>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("BeamChargeEnd"), prefix: GetHarmonyMethod(GetMethod<MaliciousFace_BeamChargeEnd>("Prefix")));
if (ConfigManager.maliciousFaceHomingProjectileToggle.value)
{
harmonyTweaks.Patch(GetMethod<SpiderBody>("ShootProj"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ShootProj_Patch>("Postfix")));
}
if (ConfigManager.maliciousFaceRadianceOnEnrage.value)
harmonyTweaks.Patch(GetMethod<SpiderBody>("Enrage"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Enrage_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("Start"), postfix: GetHarmonyMethod(GetMethod<Mindflayer_Start_Patch>("Postfix")));
if (ConfigManager.mindflayerShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mindflayer>("ShootProjectiles"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_ShootProjectiles_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_MF>("Prefix")));
}
if (ConfigManager.mindflayerTeleportComboToggle.value)
{
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("MeleeTeleport"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_MeleeTeleport_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwingCheck2>("DamageStop"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_DamageStop_Patch>("Postfix")));
}
if (ConfigManager.minosPrimeRandomTeleportToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("Postfix")));
if (ConfigManager.minosPrimeTeleportTrail.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("Teleport"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("TeleportPostfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Start"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Dropkick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Dropkick>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Combo"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Combo>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("StopAction"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_StopAction>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Ascend"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Ascend>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Death"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Death>("Prefix")));
if (ConfigManager.minosPrimeCrushAttackToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("RiderKick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_RiderKick>("Prefix")));
if (ConfigManager.minosPrimeComboExplosiveEndToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_ProjectileCharge>("Prefix")));
if (ConfigManager.schismSpreadAttackToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ShootProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ShootProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<Solider_Start_Patch>("Postfix")));
}
if(ConfigManager.soliderCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_SpawnProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootGrenadeToggle.value || ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Stalker>("SandExplode"), prefix: GetHarmonyMethod(GetMethod<Stalker_SandExplode_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SandificationZone>("Enter"), postfix: GetHarmonyMethod(GetMethod<SandificationZone_Enter_Patch>("Postfix")));
if (ConfigManager.strayCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Swing>("Postfix")));
if (ConfigManager.strayShootToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_Start_Patch1>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("DamageEnd"), prefix: GetHarmonyMethod(GetMethod<DamageEnd>("Prefix")));
}
if(ConfigManager.streetCleanerCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<Streetcleaner>("Start"), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Start_Patch>("Postfix")));
if(ConfigManager.streetCleanerPredictiveDodgeToggle.value)
harmonyTweaks.Patch(GetMethod<BulletCheck>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<BulletCheck_OnTriggerEnter_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Start"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Start>("Postfix")));
if (ConfigManager.swordsMachineNoLightKnockbackToggle.value || ConfigManager.swordsMachineSecondPhaseMode.value != ConfigManager.SwordsMachineSecondPhase.None)
{
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Knockdown"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Knockdown_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Down"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwordsMachine>("SetSpeed"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_SetSpeed_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("EndFirstPhase"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Prefix")));
}
if (ConfigManager.swordsMachineExplosiveSwordToggle.value)
{
harmonyTweaks.Patch(GetMethod<ThrownSword>("Start"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ThrownSword>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_OnTriggerEnter_Patch>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Turret>("Start"), postfix: GetHarmonyMethod(GetMethod<TurretStart>("Postfix")));
if(ConfigManager.turretBurstFireToggle.value)
{
harmonyTweaks.Patch(GetMethod<Turret>("Shoot"), prefix: GetHarmonyMethod(GetMethod<TurretShoot>("Prefix")));
harmonyTweaks.Patch(GetMethod<Turret>("StartAiming"), postfix: GetHarmonyMethod(GetMethod<TurretAim>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Explosion>("Start"), postfix: GetHarmonyMethod(GetMethod<V2CommonExplosion>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2FirstStart>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2FirstUpdate>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2FirstShootWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2SecondStart>("Postfix")));
//if(ConfigManager.v2SecondStartEnraged.value)
// harmonyTweaks.Patch(GetMethod<BossHealthBar>("OnEnable"), postfix: GetHarmonyMethod(GetMethod<V2SecondEnrage>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2SecondUpdate>("Prefix")));
//harmonyTweaks.Patch(GetMethod<V2>("AltShootWeapon"), postfix: GetHarmonyMethod(GetMethod<V2AltShootWeapon>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("SwitchWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondSwitchWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Prefix")), postfix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Postfix")));
if(ConfigManager.v2SecondFastCoinToggle.value)
harmonyTweaks.Patch(GetMethod<V2>("ThrowCoins"), prefix: GetHarmonyMethod(GetMethod<V2SecondFastCoin>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<V2RocketLauncher>("CannonBallTriggerPrefix")));
if (ConfigManager.v2FirstSharpshooterToggle.value || ConfigManager.v2SecondSharpshooterToggle.value)
{
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("PrepareAltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverPrepareAltFire>("Prefix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverBullet>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("AltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverAltShoot>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Virtue_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Virtue_SpawnInsignia_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Virtue_Death_Patch>("Prefix")));
if (ConfigManager.sisyInstJumpShockwave.value)
{
harmonyTweaks.Patch(GetMethod<Sisyphus>("Start"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Sisyphus>("Update"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Update>("Postfix")));
}
if(ConfigManager.sisyInstBoulderShockwave.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("SetupExplosion"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_SetupExplosion>("Postfix")));
if(ConfigManager.sisyInstStrongerExplosion.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("StompExplosion"), prefix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_StompExplosion>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("Awake"), postfix: GetHarmonyMethod(GetMethod<LeviathanTail_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("BigSplash"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_BigSplash>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("Start"), postfix: GetHarmonyMethod(GetMethod<Leviathan_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurst"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurstStart"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurstStart>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<Leviathan_FixedUpdate>("Prefix")));
if (ConfigManager.somethingWickedSpear.value)
{
harmonyTweaks.Patch(GetMethod<Wicked>("Start"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_GetHit>("Postfix")));
}
if(ConfigManager.somethingWickedSpawnOn43.value)
{
harmonyTweaks.Patch(GetMethod<ObjectActivator>("Activate"), prefix: GetHarmonyMethod(GetMethod<ObjectActivator_Activate>("Prefix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<JokeWicked_GetHit>("Postfix")));
}
if (ConfigManager.panopticonFullPhase.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Panopticon_Start>("Postfix")));
if (ConfigManager.panopticonAxisBeam.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnInsignia>("Prefix")));
if (ConfigManager.panopticonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<Panopticon_HomingProjectileAttack>("Postfix")));
if (ConfigManager.panopticonBlackholeProj.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnBlackHole"), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnBlackHole>("Postfix")));
if (ConfigManager.panopticonBalanceEyes.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnFleshDrones"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Postfix")));
if (ConfigManager.panopticonBlueProjToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Update"), transpiler: GetHarmonyMethod(GetMethod<Panopticon_BlueProjectile>("Transpiler")));
if (ConfigManager.idolExplosionToggle.value)
harmonyTweaks.Patch(GetMethod<Idol>("Death"), postfix: GetHarmonyMethod(GetMethod<Idol_Death_Patch>("Postfix")));
// ADDME
/*
harmonyTweaks.Patch(GetMethod<GabrielSecond>("Start"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("BasicCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_BasicCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("FastCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_FastCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("CombineSwords"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_CombineSwords>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("ThrowCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_ThrowCombo>("Postfix")));
*/
}
private static void PatchAllPlayers()
{
if (!ConfigManager.playerTweakToggle.value)
return;
harmonyTweaks.Patch(GetMethod<Punch>("CheckForProjectile"), prefix: GetHarmonyMethod(GetMethod<Punch_CheckForProjectile_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch1>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Collision"), prefix: GetHarmonyMethod(GetMethod<Grenade_Collision_Patch>("Prefix")));
if (ConfigManager.rocketBoostToggle.value)
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_Patch>("Prefix")));
if (ConfigManager.rocketGrabbingToggle.value)
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate_Patch>("Prefix")));
if (ConfigManager.orbStrikeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Coin>("Start"), postfix: GetHarmonyMethod(GetMethod<Coin_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Punch>("BlastCheck"), prefix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Postfix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide>("Prefix")));
harmonyTweaks.Patch(GetMethod<Coin>("DelayedReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_DelayedReflectRevolver>("Postfix")));
harmonyTweaks.Patch(GetMethod<Coin>("ReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Prefix")), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Postfix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("ExecuteHits"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("HitSomething"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("Start"), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_Start>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("Explode"), prefix: GetHarmonyMethod(GetMethod<Cannonball_Explode>("Prefix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_CollideOrbital>("Prefix")));
}
if(ConfigManager.chargedRevRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Revolver>("Update"), prefix: GetHarmonyMethod(GetMethod<Revolver_Update>("Prefix")));
if(ConfigManager.coinRegSpeedMulti.value != 1 || ConfigManager.sharpshooterRegSpeedMulti.value != 1
|| ConfigManager.railcannonRegSpeedMulti.value != 1 || ConfigManager.rocketFreezeRegSpeedMulti.value != 1
|| ConfigManager.rocketCannonballRegSpeedMulti.value != 1 || ConfigManager.nailgunAmmoRegSpeedMulti.value != 1
|| ConfigManager.sawAmmoRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<WeaponCharges>("Charge"), prefix: GetHarmonyMethod(GetMethod<WeaponCharges_Charge>("Prefix")));
if(ConfigManager.nailgunHeatsinkRegSpeedMulti.value != 1 || ConfigManager.sawHeatsinkRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Nailgun>("Update"), prefix: GetHarmonyMethod(GetMethod<NailGun_Update>("Prefix")));
if(ConfigManager.staminaRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("Update"), prefix: GetHarmonyMethod(GetMethod<NewMovement_Update>("Prefix")));
if(ConfigManager.playerHpDeltaToggle.value || ConfigManager.maxPlayerHp.value != 100 || ConfigManager.playerHpSupercharge.value != 200 || ConfigManager.whiplashHardDamageCap.value != 50 || ConfigManager.whiplashHardDamageSpeed.value != 1)
{
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHealth"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHealth>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("SuperCharge"), prefix: GetHarmonyMethod(GetMethod<NewMovement_SuperCharge>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Respawn"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Respawn>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Start"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Transpiler")));
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), transpiler: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate>("Transpiler")));
harmonyTweaks.Patch(GetMethod<NewMovement>("ForceAntiHP"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_ForceAntiHP>("Transpiler")));
}
// ADDME
harmonyTweaks.Patch(GetMethod<Revolver>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Revolver_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Shotgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Transpiler")), prefix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Postfix")));
harmonyTweaks.Patch(GetMethod<Shotgun>("ShootSinks"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_ShootSinks>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("SuperSaw"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_SuperSaw>("Transpiler")));
if (ConfigManager.hardDamagePercent.normalizedValue != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Prefix")), postfix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Start"), postfix: GetHarmonyMethod(GetMethod<HealthBar_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Update"), transpiler: GetHarmonyMethod(GetMethod<HealthBar_Update>("Transpiler")));
foreach (HealthBarTracker hb in HealthBarTracker.instances)
{
if (hb != null)
hb.SetSliderRange();
}
harmonyTweaks.Patch(GetMethod<Harpoon>("Start"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Start>("Postfix")));
if(ConfigManager.screwDriverHomeToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("Punched"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Punched>("Postfix")));
if(ConfigManager.screwDriverSplitToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<Harpoon_OnTriggerEnter_Patch>("Prefix")));
}
private static void PatchAllMemes()
{
if (ConfigManager.enrageSfxToggle.value)
harmonyTweaks.Patch(GetMethod<EnrageEffect>("Start"), postfix: GetHarmonyMethod(GetMethod<EnrageEffect_Start>("Postfix")));
if(ConfigManager.funnyDruidKnightSFXToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mandalore>("FullBurst"), postfix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Postfix")), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mandalore>("FullerBurst"), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullerBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Explode"), prefix: GetHarmonyMethod(GetMethod<Drone_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Drone_Explode>("Postfix")));
}
if (ConfigManager.fleshObamiumToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Prefix")));
if (ConfigManager.obamapticonToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Prefix")));
}
public static bool methodsPatched = false;
public static void ScenePatchCheck()
{
if(methodsPatched && !ultrapainDifficulty)
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
}
else if(!methodsPatched && ultrapainDifficulty)
{
PatchAll();
}
}
public static void PatchAll()
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
if (!ultrapainDifficulty)
return;
if(realUltrapainDifficulty && ConfigManager.discordRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<DiscordController>("SendActivity"), prefix: GetHarmonyMethod(GetMethod<DiscordController_SendActivity_Patch>("Prefix")));
if (realUltrapainDifficulty && ConfigManager.steamRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<SteamFriends>("SetRichPresence"), prefix: GetHarmonyMethod(GetMethod<SteamFriends_SetRichPresence_Patch>("Prefix")));
PatchAllEnemies();
PatchAllPlayers();
PatchAllMemes();
methodsPatched = true;
}
public static string workingPath;
public static string workingDir;
public static AssetBundle bundle;
public static AudioClip druidKnightFullAutoAud;
public static AudioClip druidKnightFullerAutoAud;
public static AudioClip druidKnightDeathAud;
public static AudioClip enrageAudioCustom;
public static GameObject fleshObamium;
public static GameObject obamapticon;
public void Awake()
{
instance = this;
workingPath = Assembly.GetExecutingAssembly().Location;
workingDir = Path.GetDirectoryName(workingPath);
Logger.LogInfo($"Working path: {workingPath}, Working dir: {workingDir}");
try
{
bundle = AssetBundle.LoadFromFile(Path.Combine(workingDir, "ultrapain"));
druidKnightFullAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullauto.wav");
druidKnightFullerAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullerauto.wav");
druidKnightDeathAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/death.wav");
enrageAudioCustom = bundle.LoadAsset<AudioClip>("assets/ultrapain/sfx/enraged.wav");
fleshObamium = bundle.LoadAsset<GameObject>("assets/ultrapain/fleshprison/fleshobamium.prefab");
obamapticon = bundle.LoadAsset<GameObject>("assets/ultrapain/panopticon/obamapticon.prefab");
}
catch (Exception e)
{
Logger.LogError($"Could not load the asset bundle:\n{e}");
}
// DEBUG
/*string logPath = Path.Combine(Environment.CurrentDirectory, "log.txt");
Logger.LogInfo($"Saving to {logPath}");
List<string> assetPaths = new List<string>()
{
"fonts.bundle",
"videos.bundle",
"shaders.bundle",
"particles.bundle",
"materials.bundle",
"animations.bundle",
"prefabs.bundle",
"physicsmaterials.bundle",
"models.bundle",
"textures.bundle",
};
//using (FileStream log = File.Open(logPath, FileMode.OpenOrCreate, FileAccess.Write))
//{
foreach(string assetPath in assetPaths)
{
Logger.LogInfo($"Attempting to load {assetPath}");
AssetBundle bundle = AssetBundle.LoadFromFile(Path.Combine(bundlePath, assetPath));
bundles.Add(bundle);
//foreach (string name in bundle.GetAllAssetNames())
//{
// string line = $"[{bundle.name}][{name}]\n";
// log.Write(Encoding.ASCII.GetBytes(line), 0, line.Length);
//}
bundle.LoadAllAssets();
}
//}
*/
// Plugin startup logic
Logger.LogInfo($"Plugin {PluginInfo.PLUGIN_GUID} is loaded!");
harmonyTweaks = new Harmony(PLUGIN_GUID + "_tweaks");
harmonyBase = new Harmony(PLUGIN_GUID + "_base");
harmonyBase.Patch(GetMethod<DifficultySelectButton>("SetDifficulty"), postfix: GetHarmonyMethod(GetMethod<DifficultySelectPatch>("Postfix")));
harmonyBase.Patch(GetMethod<DifficultyTitle>("Check"), postfix: GetHarmonyMethod(GetMethod<DifficultyTitle_Check_Patch>("Postfix")));
harmonyBase.Patch(typeof(PrefsManager).GetConstructor(new Type[0]), postfix: GetHarmonyMethod(GetMethod<PrefsManager_Ctor>("Postfix")));
harmonyBase.Patch(GetMethod<PrefsManager>("EnsureValid"), prefix: GetHarmonyMethod(GetMethod<PrefsManager_EnsureValid>("Prefix")));
harmonyBase.Patch(GetMethod<Grenade>("Explode"), prefix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Prefix")), postfix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Postfix")));
LoadPrefabs();
ConfigManager.Initialize();
SceneManager.activeSceneChanged += OnSceneChange;
}
}
public static class Tools
{
private static Transform _target;
private static Transform target { get
{
if(_target == null)
_target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
return _target;
}
}
public static Vector3 PredictPlayerPosition(float speedMod, Collider enemyCol = null)
{
Vector3 projectedPlayerPos;
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
{
return target.position;
}
RaycastHit raycastHit;
if (enemyCol != null && Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == enemyCol)
{
projectedPlayerPos = target.position;
}
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
projectedPlayerPos = raycastHit.point;
}
else
{
projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
projectedPlayerPos = new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
return projectedPlayerPos;
}
}
// Asset destroyer tracker
/*[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass1
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object), typeof(float) })]
public class TempClass2
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass3
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object), typeof(bool) })]
public class TempClass4
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}*/
}
| Ultrapain/Plugin.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel streetCleanerPanel;\n public static ConfigPanel swordsMachinePanel;\n public static ConfigPanel virtuePanel;\n public static ConfigPanel ferrymanPanel;\n public static ConfigPanel turretPanel;\n public static ConfigPanel fleshPrisonPanel;\n public static ConfigPanel minosPrimePanel;\n public static ConfigPanel v2FirstPanel;\n public static ConfigPanel v2SecondPanel;\n public static ConfigPanel sisyInstPanel;",
"score": 0.8611605167388916
},
{
"filename": "Ultrapain/Patches/Virtue.cs",
"retrieved_chunk": " }\n }\n class VirtueFlag : MonoBehaviour\n {\n public AudioSource lighningBoltSFX;\n public GameObject ligtningBoltAud;\n public Transform windupObj;\n private EnemyIdentifier eid;\n public Drone virtue;\n public void Awake()",
"score": 0.8595262765884399
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel leviathanPanel;\n public static ConfigPanel somethingWickedPanel;\n public static ConfigPanel panopticonPanel;\n public static ConfigPanel idolPanel;\n // GLOBAL ENEMY CONFIG\n public static BoolField friendlyFireDamageOverrideToggle;\n public static FloatSliderField friendlyFireDamageOverrideExplosion;\n public static FloatSliderField friendlyFireDamageOverrideProjectile;\n public static FloatSliderField friendlyFireDamageOverrideFire;\n public static FloatSliderField friendlyFireDamageOverrideMelee;",
"score": 0.8545547127723694
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel cerberusPanel;\n public static ConfigPanel dronePanel;\n public static ConfigPanel filthPanel;\n public static ConfigPanel hideousMassPanel;\n public static ConfigPanel maliciousFacePanel;\n public static ConfigPanel mindflayerPanel;\n public static ConfigPanel schismPanel;\n public static ConfigPanel soliderPanel;\n public static ConfigPanel stalkerPanel;\n public static ConfigPanel strayPanel;",
"score": 0.8464118838310242
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static BoolField globalDifficultySwitch;\n public static ConfigPanel memePanel;\n // MEME PANEL\n public static BoolField enrageSfxToggle;\n public static BoolField funnyDruidKnightSFXToggle;\n public static BoolField fleshObamiumToggle;\n public static StringField fleshObamiumName;\n public static BoolField obamapticonToggle;\n public static StringField obamapticonName;\n // PLAYER PANEL",
"score": 0.8451663255691528
}
] | csharp | Sprite greenRevolverSprite; |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XiaoFeng;
using XiaoFeng.Json;
using System.ComponentModel;
/****************************************************************
* Copyright © (2022) www.fayelf.com All Rights Reserved. *
* Author : jacky *
* QQ : 7092734 *
* Email : [email protected] *
* Site : www.fayelf.com *
* Create Time : 2022-03-18 13:38:33 *
* Version : v 1.0.0 *
* CLR Version : 4.0.30319.42000 *
*****************************************************************/
namespace FayElf.Plugins.WeChat.OfficialAccount.Model
{
/// <summary>
/// 模板发送数据
/// </summary>
public class IndustryTemplateSendData
{
#region 构造器
/// <summary>
/// 无参构造器
/// </summary>
public IndustryTemplateSendData()
{
}
#endregion
#region 属性
/*
* {
"touser":"OPENID",
"template_id":"ngqIpbwh8bUfcSsECmogfXcV14J0tQlEpBO27izEYtY",
"url":"http://weixin.qq.com/download",
"miniprogram":{
"appid":"xiaochengxuappid12345",
"pagepath":"index?foo=bar"
},
"data":{
"first": {
"value":"恭喜你购买成功！",
"color":"#173177"
},
"keyword1":{
"value":"巧克力",
"color":"#173177"
},
"keyword2": {
"value":"39.8元",
"color":"#173177"
},
"keyword3": {
"value":"2014年9月22日",
"color":"#173177"
},
"remark":{
"value":"欢迎再次购买！",
"color":"#173177"
}
}
}
*/
/// <summary>
/// 接收者openid
/// </summary>
[Description("接收者openid"),JsonElement("touser")]
public string ToUser { get; set; }
/// <summary>
/// 模板ID
/// </summary>
[Description("模板ID"), JsonElement("template_id")]
public string TemplateId { get; set; }
/// <summary>
/// 模板跳转链接（海外帐号没有跳转能力）
/// </summary>
[Description("模板跳转链接（海外帐号没有跳转能力）"), JsonElement("url"), OmitEmptyNode]
public string Url { get; set; }
/// <summary>
/// 跳小程序所需数据，不需跳小程序可不用传该数据
/// </summary>
[Description("跳小程序所需数据"), JsonElement("miniprogram"), OmitEmptyNode]
public MiniProgram miniprogram { get; set; }
/// <summary>
/// 模板数据
/// </summary>
[Description("模板数据"), JsonElement("data")]
public Dictionary<string, | ValueColor> Data { | get; set; }
#endregion
#region 方法
#endregion
}
/// <summary>
/// 发送数据返回结果
/// </summary>
public class IndustryTemplateSendDataResult : BaseResult
{
/// <summary>
/// 消息ID
/// </summary>
[Description("消息ID"),JsonElement("msgid")]
public string MsgID { get; set; }
}
} | OfficialAccount/Model/IndustryTemplateSendData.cs | zhuovi-FayElf.Plugins.WeChat-5725d1e | [
{
"filename": "Applets/Model/UniformSendData.cs",
"retrieved_chunk": " /// </summary>\n public string url { get; set; }\n /// <summary>\n /// 公众号模板消息所要跳转的小程序，小程序的必须与公众号具有绑定关系\n /// </summary>\n [OmitEmptyNode]\n public MiniProgram miniprogram { get; set; }\n /// <summary>\n /// 公众号模板消息的数据\n /// </summary>",
"score": 0.8582214713096619
},
{
"filename": "OfficialAccount/Model/IndustryTemplateListResult.cs",
"retrieved_chunk": " /// <summary>\n /// 模板内容\n /// </summary>\n [Description(\"模板内容\"), JsonElement(\"content\")]\n public string Content { get; set; }\n /// <summary>\n /// 模板示例\n /// </summary>\n [Description(\"模板示例\"), JsonElement(\"example\")]\n public string Example { get; set; }",
"score": 0.8523743152618408
},
{
"filename": "OfficialAccount/Model/ButtonModel.cs",
"retrieved_chunk": " /// </summary>\n [JsonElement(\"media_id\"), OmitEmptyNode]\n public string MediaId { get; set; }\n /// <summary>\n /// 发布后获得的合法 article_id\n /// </summary>\n [JsonElement(\"article_id\"), OmitEmptyNode]\n public string ArticleId { get; set; }\n /// <summary>\n /// 网页 链接，用户点击菜单可打开链接，不超过1024字节。 type为miniprogram时，不支持小程序的老版本客户端将打开本url。",
"score": 0.850554347038269
},
{
"filename": "OfficialAccount/Model/IndustryTemplateListResult.cs",
"retrieved_chunk": " /// <summary>\n /// 模板ID\n /// </summary>\n [Description(\"模板ID\"),JsonElement(\"template_id\")]\n public string TemplateID { get; set; }\n /// <summary>\n /// 模板标题\n /// </summary>\n [Description(\"模板标题\"), JsonElement(\"title\")]\n public string Title { get; set; }",
"score": 0.8497886061668396
},
{
"filename": "OfficialAccount/Model/ButtonModel.cs",
"retrieved_chunk": " /// </summary>\n [JsonElement(\"url\"), OmitEmptyNode]\n public string Url { get; set; }\n /// <summary>\n /// 小程序的appid（仅认证公众号可配置）\n /// </summary>\n [JsonElement(\"appid\"), OmitEmptyNode]\n public string AppId { get; set; }\n /// <summary>\n /// 小程序的页面路径",
"score": 0.8471508622169495
}
] | csharp | ValueColor> Data { |
using Gum.Utilities;
using Newtonsoft.Json;
using System.Diagnostics;
namespace Gum.InnerThoughts
{
[DebuggerDisplay("{Name}")]
public class Situation
{
[JsonProperty]
public readonly int Id = 0;
[JsonProperty]
public readonly string Name = string.Empty;
public int Root = 0;
public readonly List<Block> Blocks = new();
/// <summary>
/// This points
/// [ Node Id -> Edge ]
/// </summary>
public readonly Dictionary<int, Edge> Edges = new();
/// <summary>
/// This points
/// [ Node Id -> Parent ]
/// If parent is empty, this is at the top.
/// </summary>
public readonly Dictionary<int, HashSet<int>> ParentOf = new();
private readonly Stack<int> _lastBlocks = new();
public Situation() { }
public Situation(int id, string name)
{
Id = id;
Name = name;
// Add a root node.
Block block = CreateBlock(playUntil: -1, track: true);
Edge edge = CreateEdge(EdgeKind.Next);
AssignOwnerToEdge(block.Id, edge);
Root = block.Id;
}
public bool SwitchRelationshipTo(EdgeKind kind)
{
Edge lastEdge = LastEdge;
if (lastEdge.Kind == kind)
{
// No operation, relationship is already set.
return true;
}
int length = lastEdge.Blocks.Count;
switch (kind)
{
case EdgeKind.Next:
case EdgeKind.Random:
lastEdge.Kind = kind;
return true;
case EdgeKind.Choice:
case EdgeKind.HighestScore:
if (length == 1)
{
lastEdge.Kind = kind;
}
else
{
Debug.Fail("I don't understand this scenario fully, please debug this.");
// Remove the last block and create a new one?
}
return true;
case EdgeKind.IfElse:
return false;
}
return true;
}
internal EdgeKind PeekLastEdgeKind() => LastEdge.Kind;
internal Block PeekLastBlock() => Blocks[_lastBlocks.Peek()];
internal | Block PeekLastBlockParent() => Blocks[_lastBlocks.ElementAt(1)]; |
internal Block PeekBlockAt(int level) => Blocks[_lastBlocks.ElementAt(level)];
/// <summary>
/// Creates a new block subjected to a <paramref name="kind"/> relationship.
/// </summary>
public Block? AddBlock(int playUntil, int joinLevel, bool isNested, EdgeKind kind = EdgeKind.Next)
{
Block lastBlock = PeekLastBlock();
if (joinLevel == 0 && playUntil == 1 && lastBlock.PlayUntil == 1 && !lastBlock.NonLinearNode)
{
// Consider this:
// @1 -> Go
//
// @1 Some other dialog with the same indentation.
// -> exit!
// We need to "fake" another join level here to make up for our lack of indentation.
joinLevel += 1;
}
// We need to know the "parent" node when nesting blocks (make the parent -> point to the new block).
(int parentId, int[] blocksToBeJoined) = FetchParentOfJoinedBlock(joinLevel, kind);
Edge lastEdge = Edges[parentId];
// Looks on whether we need to pop nodes on:
// >> Dialog
// > Choice
// > Choice 2 <- pop here!
bool shouldPopChoiceBlock = kind == EdgeKind.Choice && Blocks[parentId].IsChoice && lastEdge.Kind != kind && !isNested;
if (shouldPopChoiceBlock || (!kind.IsSequential() && Blocks[parentId].NonLinearNode))
{
// This is the only "HACKY" thing I will allow here.
// Since I want to avoid a syntax such as:
// (condition)
// @score
// - something
// - something
// and instead have something like
// (condition)
// - something
// - something
// I will do the following:
_lastBlocks.Pop();
parentId = _lastBlocks.Peek();
blocksToBeJoined = new int[] { parentId };
}
// Do not make a join on the leaves if this is an (...) or another choice (-/+)
if (kind == EdgeKind.IfElse ||
(!lastEdge.Kind.IsSequential() && !kind.IsSequential()) ||
(kind == EdgeKind.Choice && lastEdge.Kind == EdgeKind.Choice))
{
blocksToBeJoined = new int[] { parentId };
}
Block block = CreateBlock(playUntil, track: true);
block.NonLinearNode = !kind.IsSequential();
block.IsChoice = kind == EdgeKind.Choice;
Edge? edge = CreateEdge(EdgeKind.Next);
AssignOwnerToEdge(block.Id, edge);
// If this was called right after a situation has been declared, it'll think that it is a nested block
// (when it's not really).
if (isNested)
{
Edge? parentEdge = Edges[parentId];
if (block.IsChoice)
{
parentEdge.Kind = EdgeKind.Next;
// (Condition)
// >> Nested title
// > Option a
// > Option b
edge.Kind = kind;
}
else
{
parentEdge.Kind = kind;
}
AddNode(parentEdge, block.Id);
return block;
}
foreach (int parent in blocksToBeJoined)
{
JoinBlock(block, edge, parent, kind);
}
return block;
}
private bool JoinBlock(Block block, Edge nextEdge, int parentId, EdgeKind kind)
{
Edge lastEdge = Edges[parentId];
switch (kind)
{
case EdgeKind.Choice:
if (lastEdge.Kind != EdgeKind.Choice)
{
// before:
// .
// | D
// A
//
// after:
// .
// |
// A
// |
// D
// {choice}
lastEdge = Edges[parentId];
AddNode(lastEdge, block.Id);
nextEdge.Kind = kind;
return true;
}
AddNode(lastEdge, block.Id);
return true;
case EdgeKind.HighestScore:
case EdgeKind.Random:
// nextEdge.Kind = EdgeKind.HighestScore;
break;
case EdgeKind.IfElse:
if (lastEdge.Kind == EdgeKind.IfElse ||
(lastEdge.Kind.IsSequential() && lastEdge.Blocks.Count == 1))
{
lastEdge.Kind = EdgeKind.IfElse;
AddNode(lastEdge, block.Id);
return true;
}
if (lastEdge.Blocks.Count > 1)
{
CreateDummyNodeAt(lastEdge.Blocks.Last(), block.Id, kind);
return true;
}
Debug.Fail("Empty edge?");
return false;
}
if (kind == EdgeKind.IfElse && lastEdge.Kind != kind)
{
if (lastEdge.Kind != EdgeKind.Next)
{
CreateDummyNodeAt(parentId, block.Id, kind);
return true;
}
// This has been a bit of a headache, but if this is an "if else" and the current connection
// is not the same, we'll convert this later.
kind = EdgeKind.Next;
}
// If this is "intruding" an existing nested if-else.
// (hasA)
// (hasB)
// (...)
// (...)
else if (kind == EdgeKind.IfElse && lastEdge.Kind == kind && parentId == lastEdge.Owner)
{
CreateDummyNodeAt(parentId, block.Id, kind);
return true;
}
if (kind == EdgeKind.HighestScore && lastEdge.Kind == EdgeKind.Random)
{
// A "HighestScore" kind when is matched with a "random" relationship, it is considered one of them
// automatically.
kind = EdgeKind.Random;
}
if (lastEdge.Kind != kind && lastEdge.Blocks.Count == 0)
{
lastEdge.Kind = kind;
}
else if (lastEdge.Kind != kind && kind == EdgeKind.HighestScore)
{
// No-op?
}
else if (lastEdge.Kind != kind)
{
CreateDummyNodeAt(parentId, block.Id, kind);
return true;
}
AddNode(lastEdge, block.Id);
return true;
}
/// <summary>
/// Given C and D:
/// Before:
/// A
/// / \
/// B C <- parent D <- block
/// /
/// ...
///
/// After:
/// A
/// / \
/// B E <- dummy
/// / \
/// C D
/// /
///...
///
/// </summary>
private void CreateDummyNodeAt(int parentId, int blockId, EdgeKind kind)
{
Block lastBlock = Blocks[parentId];
// Block the last block, this will be the block that we just added (blockId).
_ = _lastBlocks.TryPop(out _);
// If this block corresponds to the parent, remove it from the stack.
if (_lastBlocks.TryPeek(out int peek) && peek == parentId)
{
_ = _lastBlocks.Pop();
}
Block empty = CreateBlock(playUntil: lastBlock.PlayUntil, track: true);
ReplaceEdgesToNodeWith(parentId, empty.Id);
_lastBlocks.Push(blockId);
Edge lastEdge = CreateEdge(kind);
AddNode(lastEdge, parentId);
AddNode(lastEdge, blockId);
AssignOwnerToEdge(empty.Id, lastEdge);
}
/// <summary>
/// Find all leaf nodes eligible to be joined.
/// This will disregard nodes that are already dead (due to a goto!).
/// </summary>
private void GetAllLeaves(int block, bool createBlockForElse, ref HashSet<int> result)
{
Edge edge = Edges[block];
if (edge.Blocks.Count != 0)
{
foreach (int otherBlock in edge.Blocks)
{
GetAllLeaves(otherBlock, createBlockForElse, ref result);
}
if (createBlockForElse)
{
// @1 (Something)
// Hello!
//
// (...Something2)
// Hello once?
// Bye.
//
// turns into:
// @1 (Something)
// Hello!
//
// (...Something2)
// Hello once?
//
// (...)
// // go down.
//
// Bye.
// If this an else if, but may not enter any of the blocks,
// do a last else to the next block.
if (edge.Kind == EdgeKind.IfElse &&
Blocks[edge.Blocks.Last()].Requirements.Count != 0)
{
// Create else block and its edge.
int elseBlockId = CreateBlock(-1, track: false).Id;
Edge? elseBlockEdge = CreateEdge(EdgeKind.Next);
AssignOwnerToEdge(elseBlockId, elseBlockEdge);
// Assign the block as part of the .IfElse edge.
AddNode(edge, elseBlockId);
// Track the block as a leaf.
result.Add(elseBlockId);
}
}
}
else
{
if (!_blocksWithGoto.Contains(block))
{
// This doesn't point to any other blocks - so it's a leaf!
result.Add(block);
}
}
}
private (int Parent, int[] blocksToBeJoined) FetchParentOfJoinedBlock(int joinLevel, EdgeKind edgeKind)
{
int topParent;
if (joinLevel == 0)
{
topParent = _lastBlocks.Peek();
return (topParent, new int[] { topParent });
}
while (_lastBlocks.Count > 1 && joinLevel-- > 0)
{
int blockId = _lastBlocks.Pop();
Block block = Blocks[blockId];
// When I said I would allow one (1) hacky code, I lied.
// This is another one.
// SO, the indentation gets really weird for conditionals, as we pretty
// much disregard one indent? I found that the best approach to handle this is
// manually cleaning up the stack when there is NOT a conditional block on join.
// This is also true for @[0-9] blocks, since those add an extra indentation.
if (block.NonLinearNode)
{
if (block.Conditional)
{
// Nevermind the last pop: this is actually not an indent at all, as the last
// block was actually a condition (and we have a minus one indent).
_lastBlocks.Push(blockId);
}
else if (Edges[ParentOf[blockId].First()].Kind != EdgeKind.HighestScore)
{
// Skip indentation for non linear nodes with the default setting.
// TODO: Check how that breaks join with @order? Does it actually break?
// no-op.
}
else
{
joinLevel++;
}
}
else if (!block.Conditional)
{
// [parent]
// @1 Conditional
// Line
//
// And the other block.
// but not here:
// >> something
// > a
// >> b
// > c
// > d <-
if (block.PlayUntil == -1 && (!block.IsChoice || edgeKind != EdgeKind.Choice))
{
joinLevel++;
}
}
}
topParent = _lastBlocks.Peek();
int[] blocksToLookForLeaves = Edges[topParent].Blocks.ToArray();
HashSet<int> leafBlocks = new();
// Now, for each of those blocks, we'll collect all of its leaves and add edges to it.
foreach (int blockToJoin in blocksToLookForLeaves)
{
GetAllLeaves(blockToJoin, createBlockForElse: edgeKind != EdgeKind.IfElse, ref leafBlocks);
}
leafBlocks.Add(topParent);
if (leafBlocks.Count != 0)
{
HashSet<int> prunnedLeafBlocks = leafBlocks.ToHashSet();
foreach (int b in prunnedLeafBlocks)
{
if (b != topParent)
{
// Whether this block will always be played or is it tied to a condition.
// If this is tied to the root directly, returns -1.
int conditionalParent = GetConditionalBlock(b);
if (conditionalParent == -1 || conditionalParent == topParent)
{
prunnedLeafBlocks.Remove(topParent);
}
}
// If the last block doesn't have any condition *but* this is actually an
// if else block.
// I *think* this doesn't take into account child of child blocks, but it's not
// the end of the world if we have an extra edge that will never be reached.
switch (Edges[b].Kind)
{
case EdgeKind.IfElse:
if (Edges[b].Blocks.LastOrDefault() is int lastBlockId)
{
if (Blocks[lastBlockId].Requirements.Count == 0 &&
prunnedLeafBlocks.Contains(lastBlockId))
{
prunnedLeafBlocks.Remove(b);
}
}
break;
case EdgeKind.HighestScore:
case EdgeKind.Choice:
case EdgeKind.Random:
prunnedLeafBlocks.Remove(b);
break;
}
}
leafBlocks = prunnedLeafBlocks;
}
return (topParent, leafBlocks.ToArray());
}
private int GetConditionalBlock(int block)
{
if (Blocks[block].PlayUntil != -1)
{
return block;
}
if (Blocks[block].Requirements.Count != 0)
{
return block;
}
if (ParentOf[block].Contains(0))
{
// This is tied to the root and the block can play forever.
return -1;
}
int result = -1;
foreach (int parent in ParentOf[block])
{
result = GetConditionalBlock(parent);
if (result == -1)
{
break;
}
}
return result;
}
/// <summary>
/// Creates a new block and assign an id to it.
/// </summary>
private Block CreateBlock(int playUntil, bool track)
{
int id = Blocks.Count;
Block block = new(id, playUntil);
Blocks.Add(block);
if (track)
{
_lastBlocks.Push(id);
}
ParentOf[id] = new();
return block;
}
private Edge CreateEdge(EdgeKind kind)
{
Edge relationship = new(kind);
return relationship;
}
private void AssignOwnerToEdge(int id, Edge edge)
{
Edges.Add(id, edge);
edge.Owner = id;
// Track parents.
foreach (int block in edge.Blocks)
{
ParentOf[block].Add(id);
}
}
private void AddNode(Edge edge, int id)
{
edge.Blocks.Add(id);
if (edge.Owner != -1)
{
ParentOf[id].Add(edge.Owner);
}
}
/// <summary>
/// Given C and D:
/// Before:
/// A D
/// / \
/// B C
///
/// D
/// After:
/// A C
/// / \
/// B D
/// This assumes that <paramref name="other"/> is an orphan.
/// <paramref name="id"/> will be orphan after this.
/// </summary>
private void ReplaceEdgesToNodeWith(int id, int other)
{
if (Root == id)
{
Root = other;
}
foreach (int parent in ParentOf[id])
{
// Manually tell each parent that the child has stopped existing.
int position = Edges[parent].Blocks.IndexOf(id);
Edges[parent].Blocks[position] = other;
ParentOf[other].Add(parent);
}
ParentOf[id].Clear();
}
private bool IsParentOf(int parentNode, int childNode)
{
if (ParentOf[childNode].Count == 0)
{
return false;
}
if (ParentOf[childNode].Contains(parentNode))
{
return true;
}
foreach (int otherParent in ParentOf[childNode])
{
if (IsParentOf(parentNode, otherParent))
{
return true;
}
}
return false;
}
public void PopLastBlock()
{
if (_lastBlocks.Count > 1)
{
_ = _lastBlocks.Pop();
}
}
private Edge LastEdge => Edges[_lastBlocks.Peek()];
private readonly HashSet<int> _blocksWithGoto = new();
public void MarkGotoOnBlock(int block, bool isExit)
{
if (isExit)
{
Blocks[block].Exit();
}
_ = _blocksWithGoto.Add(block);
}
}
}
| src/Gum/InnerThoughts/Situation.cs | isadorasophia-gum-032cb2d | [
{
"filename": "src/Gum.Tests/Bungee.cs",
"retrieved_chunk": " Assert.AreEqual(EdgeKind.Next, target.Kind);\n Assert.AreEqual(target.Owner, 0);\n CollectionAssert.AreEqual(new int[] { 1 }, target.Blocks);\n }\n [TestMethod]\n public void TestSingleCondition()\n {\n const string situationText = @\"\n=Encounter\n (!HasSeenThis)",
"score": 0.8379584550857544
},
{
"filename": "src/Gum.Tests/Bungee.cs",
"retrieved_chunk": " Assert.AreEqual(EdgeKind.Next, target.Kind);\n Assert.AreEqual(4, target.Owner);\n CollectionAssert.AreEqual(new int[] { 5 }, target.Blocks);\n }\n [TestMethod]\n public void TestElseAfterChoice()\n {\n const string situationText = @\"\n=Dinner\n (Socks >= 5)",
"score": 0.8302463293075562
},
{
"filename": "src/Gum.Tests/Bungee.cs",
"retrieved_chunk": " Assert.AreEqual(EdgeKind.Next, target.Kind);\n Assert.AreEqual(3, target.Owner);\n CollectionAssert.AreEqual(new int[] { 4 }, target.Blocks);\n }\n [TestMethod]\n public void TestNestedCondition4()\n {\n const string situationText = @\"\n=Encounter\n @1 (!SawMe)",
"score": 0.8279236555099487
},
{
"filename": "src/Gum.Tests/Bungee.cs",
"retrieved_chunk": " Assert.AreEqual(EdgeKind.Next, target.Kind);\n Assert.AreEqual(4, target.Owner);\n CollectionAssert.AreEqual(new int[] { 6 }, target.Blocks);\n }\n [TestMethod]\n public void TestNestedCondition6()\n {\n const string situationText = @\"\n=Encounter\n @1 (Defeated)",
"score": 0.8253446817398071
},
{
"filename": "src/Gum.Tests/Bungee.cs",
"retrieved_chunk": " Assert.IsTrue(situation != null);\n Edge target = situation.Edges[0];\n Assert.AreEqual(EdgeKind.Next, target.Kind);\n Assert.AreEqual(target.Owner, 0);\n CollectionAssert.AreEqual(new int[] { 1 }, target.Blocks);\n }\n [TestMethod]\n public void TestSimpleIf()\n {\n const string situationText = @\"",
"score": 0.8245543837547302
}
] | csharp | Block PeekLastBlockParent() => Blocks[_lastBlocks.ElementAt(1)]; |
using HarmonyLib;
using UnityEngine.UI;
namespace Ultrapain.Patches
{
public class DifficultyTitle_Check_Patch
{
static void Postfix(DifficultyTitle __instance, ref | Text ___txt)
{ |
if (___txt.text.Contains("ULTRAKILL MUST DIE") && Plugin.realUltrapainDifficulty)
___txt.text = ___txt.text.Replace("ULTRAKILL MUST DIE", ConfigManager.pluginName.value);
//else if (___txt.text == "-- VIOLENT --" && Plugin.ultrapainDifficulty)
// ___txt.text = "-- ULTRAPAIN --";
}
}
}
| Ultrapain/Patches/DifficultyTitle.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/StreetCleaner.cs",
"retrieved_chunk": "using HarmonyLib;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class StreetCleaner_Start_Patch\n {\n static void Postfix(Streetcleaner __instance, ref EnemyIdentifier ___eid)\n {\n ___eid.weakPoint = null;\n }",
"score": 0.8682602643966675
},
{
"filename": "Ultrapain/Patches/SteamFriends.cs",
"retrieved_chunk": "using HarmonyLib;\nusing Steamworks;\nusing System.Text.RegularExpressions;\nnamespace Ultrapain.Patches\n{\n class SteamFriends_SetRichPresence_Patch\n {\n static bool Prefix(string __0, ref string __1)\n {\n if (__1.ToLower() != \"ukmd\")",
"score": 0.8544082641601562
},
{
"filename": "Ultrapain/Patches/Idol.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Text;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class Idol_Death_Patch\n {\n static void Postfix(Idol __instance)\n {",
"score": 0.8538500070571899
},
{
"filename": "Ultrapain/Patches/CustomProgress.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nnamespace Ultrapain.Patches\n{\n /*[HarmonyPatch(typeof(GameProgressSaver), \"GetGameProgress\", new Type[] { typeof(int) })]\n class CustomProgress_GetGameProgress\n {\n static bool Prefix(ref int __0)\n {\n if (Plugin.ultrapainDifficulty)",
"score": 0.8509539365768433
},
{
"filename": "Ultrapain/Patches/Filth.cs",
"retrieved_chunk": "using HarmonyLib;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class SwingCheck2_CheckCollision_Patch2\n {\n static bool Prefix(SwingCheck2 __instance, Collider __0, EnemyIdentifier ___eid)\n {\n if (__0.gameObject.tag != \"Player\")\n return true;",
"score": 0.8504325151443481
}
] | csharp | Text ___txt)
{ |
using SemanticXamlPrint.Parser.Components;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
namespace SemanticXamlPrint
{
internal static class GraphicsExtensions
{
public static float DrawComponent(this Graphics graphics, IXamlComponent component, ComponentDrawingFormatting TemplateFormatting, float currentX, float currentY, float maxLayoutWidth)
{
maxLayoutWidth = maxLayoutWidth == 0 ? graphics.VisibleClipBounds.Width : maxLayoutWidth;
//Draw
if (component.Type == typeof(LineBreakComponent))
{
currentY += 3;
}
else if (component.Type == typeof(LineComponent))
{
LineComponent lineComponent = (LineComponent)component;
currentY += 3;
currentY += graphics.DrawlLineAndReturnHeight(lineComponent.Style.ToDashStyle(), currentX, currentY, (int)maxLayoutWidth);
currentY += 3;
}
else if (component.Type == typeof(ImageComponent))
{
ImageComponent imageComponent = (ImageComponent)component;
string imageSource = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, imageComponent.Source ?? "default.png");
if (File.Exists(imageSource))
{
currentY += graphics.DrawImageCenteredAndReturnHeight(Image.FromFile(imageSource), currentX, currentY, imageComponent.Width, imageComponent.Height, maxLayoutWidth);
}
}
else if (component.Type == typeof(QRCodeComponent))
{
QRCodeComponent qRCodeComponent = (QRCodeComponent)component;
currentY += graphics.DrawQRCodeCenteredAndReturnHeight(qRCodeComponent.Text, currentX, currentY, qRCodeComponent.Width, qRCodeComponent.Height, maxLayoutWidth);
}
else if (component.Type == typeof(DataComponent))
{
DataComponent dataComponent = (DataComponent)component;
ComponentDrawingFormatting fmt = component.GetSystemDrawingProperties(TemplateFormatting);
//Draw Data Component
currentY += graphics.DrawStringAndReturnHeight(dataComponent.Text, dataComponent.TextWrap, fmt, currentX, currentY, (int)maxLayoutWidth);
}
else if (component.Type == typeof(CellsComponent))
{
CellsComponent dataRowComponent = (CellsComponent)component;
ComponentDrawingFormatting rowfmt = component.GetSystemDrawingProperties(TemplateFormatting);
//Get all Children of DataRowCells
List<CellComponent> dataRowCells = dataRowComponent.Children?.Where(element => element.Type == typeof(CellComponent)).Select(validElement => (CellComponent)validElement).ToList();
int additionalHeight = 0;
foreach (CellComponent cell in dataRowCells)
{
ComponentDrawingFormatting cellFmt = cell.GetSystemDrawingProperties(rowfmt);
//Set RowCell Location
float x = (cell.X <= 0) ? 0f : cell.X;
float y = (cell.Y <= 0) ? currentY : cell.Y;
float z = (cell.Z <= 0) ? (int)maxLayoutWidth : cell.Z;
//Write String
int textHeight = graphics.DrawStringAndReturnHeight(cell.Text, cell.TextWrap, cellFmt, x, y, z);
additionalHeight = (textHeight > additionalHeight) ? textHeight : additionalHeight;
}
//Add Line Height
currentY += additionalHeight;
}
else if (component.Type == typeof(GridComponent))
{
GridComponent gridComponent = (GridComponent)component;
ComponentDrawingFormatting gridfmt = component.GetSystemDrawingProperties(TemplateFormatting);
List<int> columnWidths = graphics.GetDivideColumnWidths(gridComponent.ColumnWidths, maxLayoutWidth);
float y_before_grid = currentY;
float longest_column_y = currentY;
//Get Grid Rows
List<GridRowComponent> gridRows = gridComponent.Children?.Where(element => element.Type == typeof(GridRowComponent)).Select(validElement => (GridRowComponent)validElement).ToList();
foreach (GridRowComponent row in gridRows)
{
float current_y = longest_column_y;
float current_x = currentX;
ComponentDrawingFormatting rowFmt = row.GetSystemDrawingProperties(gridfmt);
for (int colIndex = 0; colIndex < columnWidths.Count; colIndex++)
{
IXamlComponent componentUnderColumn = row.Children?.FirstOrDefault(x => x.CustomProperties.IsPropertyExistsWithValue("grid.column", colIndex.ToString()));
if (componentUnderColumn != null)
{
float new_y = graphics.DrawComponent(componentUnderColumn, rowFmt, current_x, current_y, columnWidths[colIndex]);
longest_column_y = (new_y > longest_column_y) ? new_y : longest_column_y;
//Next Column Starting X co-ordinates
current_x += columnWidths[colIndex];
}
}
}
//set Highest Column Height
currentY = longest_column_y;
//# Check if Drawing Border
if (!string.IsNullOrEmpty(gridComponent.BorderStyle))
{
graphics.DrawRectangleAndReturnHeight(gridComponent.BorderStyle.ToDashStyle(), currentX, y_before_grid, (int)maxLayoutWidth, (currentY - y_before_grid), gridComponent.BorderWidth);
float current_x = currentX;
for (int colIndex = 0; colIndex < columnWidths.Count; colIndex++)
{
graphics.DrawRectangleAndReturnHeight(gridComponent.BorderStyle.ToDashStyle(), current_x, y_before_grid, columnWidths[colIndex], (currentY - y_before_grid), gridComponent.BorderWidth);
current_x += columnWidths[colIndex];
}
}
}
else
{
//unknown Component
}
return currentY;
}
public static int DrawStringAndReturnHeight(this Graphics graphics, string text, bool textWrap, | ComponentDrawingFormatting cellFmt, float x, float y, float z)
{ |
text = text ?? string.Empty;
if (textWrap && (int)graphics.MeasureString(text, cellFmt.Font).Width > z)
{
SizeF size = graphics.MeasureString(text, cellFmt.Font, (int)z);
RectangleF layoutF = new RectangleF(new PointF(x, y), size);
graphics.DrawString(text, cellFmt.Font, cellFmt.Brush, layoutF, cellFmt.StringFormat);
return (int)layoutF.Height;
}
else
{
SizeF size = graphics.MeasureString(text, cellFmt.Font, (int)z, new StringFormat { FormatFlags = StringFormatFlags.NoWrap });
Rectangle layout = new Rectangle((int)x, (int)y, (int)z, (int)size.Height);
graphics.DrawString(text, cellFmt.Font, cellFmt.Brush, layout, cellFmt.StringFormat);
return layout.Height;
}
}
public static List<int> GetDivideColumnWidths(this Graphics graphics, string pattern, float maxLayoutWith)
{
try
{
if (string.IsNullOrEmpty(pattern)) return GetDivideColumnWidths(graphics, 1, maxLayoutWith);
List<int> columnWidths = new List<int>();
int total = pattern.Split(new char[] { '*' }, StringSplitOptions.RemoveEmptyEntries).Sum(p => Convert.ToInt32(p));
if (total < 1) return GetDivideColumnWidths(graphics, 1, maxLayoutWith);
int remainingWidth = (int)maxLayoutWith;
foreach (string s in pattern.Split('*'))
{
int w = (int)Math.Round((double)remainingWidth / total * Convert.ToInt32(s));
columnWidths.Add(w);
remainingWidth -= w;
total -= Convert.ToInt32(s);
}
return columnWidths;
}
catch { return GetDivideColumnWidths(graphics, 1, maxLayoutWith); }
}
public static List<int> GetDivideColumnWidths(this Graphics graphics, int columns, float maxLayoutWith)
{
columns = columns <= 0 ? 1 : columns;
int evenColumnWidth = (int)maxLayoutWith / columns;
List<int> columnWidths = new List<int>();
for (var i = 0; i < columns; i += 1)
columnWidths.Add(evenColumnWidth);
return columnWidths;
}
public static int DrawlLineAndReturnHeight(this Graphics graphics, DashStyle dashStyle, float x, float y, float z)
{
using (Pen pen = new Pen(Color.Black) { DashStyle = dashStyle })
{
graphics.DrawLine(pen, x, y, z, y);
}
return 1;
}
public static int DrawImageCenteredAndReturnHeight(this Graphics graphics, Image image, float x, float y, float maxWidth, float maxHeight, float maxLayoutWith)
{
float newWidth = Math.Min(image.Height, maxWidth > 0 ? maxWidth : image.Width);
float newHeight = Math.Min(image.Height, maxHeight > 0 ? maxHeight : image.Height);
float centeredX = x + (maxLayoutWith - newWidth) / 2;
graphics.DrawImage(image, centeredX > 0 ? centeredX : x, y, newWidth, newHeight);
return (int)newHeight;
}
public static int DrawRectangleAndReturnHeight(this Graphics graphics, DashStyle dashStyle, float x, float y, float z, float height, double lineWidth = 0.3)
{
using (Pen pen = new Pen(Color.Black, (float)lineWidth) { DashStyle = dashStyle })
{
graphics.DrawRectangle(pen, x, y, z, height);
}
return (int)height;
}
}
}
| SemanticXamlPrint/Extensions/GraphicsExtensions.cs | swagfin-SemanticXamlPrint-41d87fa | [
{
"filename": "SemanticXamlPrint.PDF/Extensions/XGraphicsExtensions.cs",
"retrieved_chunk": " {\n //unknown Component\n }\n return currentY;\n }\n public static int DrawStringAndReturnHeight(this XGraphics gfx, string text, bool textWrap, ComponentXDrawingFormatting cellFmt, double x, double y, double z)\n {\n text = text ?? string.Empty;\n XFont font = cellFmt.Font;\n XStringFormat stringFormat = cellFmt.StringFormat;",
"score": 0.9287409782409668
},
{
"filename": "SemanticXamlPrint.PDF.NetCore/Extensions/XGraphicsExtensions.cs",
"retrieved_chunk": " {\n //unknown Component\n }\n return currentY;\n }\n public static int DrawStringAndReturnHeight(this XGraphics gfx, string text, bool textWrap, ComponentXDrawingFormatting cellFmt, double x, double y, double z)\n {\n text = text ?? string.Empty;\n XFont font = cellFmt.Font;\n XStringFormat stringFormat = cellFmt.StringFormat;",
"score": 0.9287409782409668
},
{
"filename": "SemanticXamlPrint.PDF/Extensions/XGraphicsExtensions.cs",
"retrieved_chunk": " }\n public static int DrawlLineAndReturnHeight(this XGraphics graphics, XDashStyle dashStyle, float x, float y, float z)\n {\n XPen pen = new XPen(XColors.Black)\n {\n DashStyle = dashStyle\n };\n graphics.DrawLine(pen, x, y, z, y);\n return 1;\n }",
"score": 0.8789898157119751
},
{
"filename": "SemanticXamlPrint.PDF.NetCore/Extensions/XGraphicsExtensions.cs",
"retrieved_chunk": " }\n public static int DrawlLineAndReturnHeight(this XGraphics graphics, XDashStyle dashStyle, float x, float y, float z)\n {\n XPen pen = new XPen(XColors.Black)\n {\n DashStyle = dashStyle\n };\n graphics.DrawLine(pen, x, y, z, y);\n return 1;\n }",
"score": 0.8789898157119751
},
{
"filename": "SemanticXamlPrint.PDF/Extensions/XGraphicsExtensions.cs",
"retrieved_chunk": " public static class XGraphicsExtensions\n {\n public static float DrawComponent(this XGraphics graphics, IXamlComponent component, ComponentXDrawingFormatting TemplateFormatting, float currentX, float currentY, float maxLayoutWidth)\n {\n maxLayoutWidth = maxLayoutWidth == 0 ? (float)graphics.PageSize.Width : maxLayoutWidth;\n //Draw\n if (component.Type == typeof(LineBreakComponent))\n {\n currentY += 3;\n }",
"score": 0.8712655901908875
}
] | csharp | ComponentDrawingFormatting cellFmt, float x, float y, float z)
{ |
#nullable enable
using System;
using System.Collections.Generic;
namespace Mochineko.FacialExpressions.Emotion
{
/// <summary>
/// Composition of some <see cref="Mochineko.FacialExpressions.Emotion.IEmotionMorpher{TEmotion}"/>s.
/// </summary>
/// <typeparam name="TEmotion"></typeparam>
public sealed class CompositeEmotionMorpher<TEmotion>
: IEmotionMorpher<TEmotion>
where TEmotion : Enum
{
private readonly IReadOnlyList<IEmotionMorpher<TEmotion>> morphers;
/// <summary>
/// Creates a new instance of <see cref="Mochineko.FacialExpressions.Emotion.CompositeEmotionMorpher{TEmotion}"/>.
/// </summary>
/// <param name="morphers">Composited morphers.</param>
public CompositeEmotionMorpher(IReadOnlyList<IEmotionMorpher<TEmotion>> morphers)
{
this.morphers = morphers;
}
void | IEmotionMorpher<TEmotion>.MorphInto(EmotionSample<TEmotion> sample)
{ |
foreach (var morpher in morphers)
{
morpher.MorphInto(sample);
}
}
float IEmotionMorpher<TEmotion>.GetWeightOf(TEmotion emotion)
{
return morphers[0].GetWeightOf(emotion);
}
void IEmotionMorpher<TEmotion>.Reset()
{
foreach (var morpher in morphers)
{
morpher.Reset();
}
}
}
}
| Assets/Mochineko/FacialExpressions/Emotion/CompositeEmotionMorpher.cs | mochi-neko-facial-expressions-unity-ab0d020 | [
{
"filename": "Assets/Mochineko/FacialExpressions/LipSync/CompositeLipMorpher.cs",
"retrieved_chunk": " /// <summary>\n /// Creates a new instance of <see cref=\"Mochineko.FacialExpressions.LipSync.CompositeLipMorpher\"/>.\n /// </summary>\n /// <param name=\"morphers\">Composited morphers.</param>\n public CompositeLipMorpher(IReadOnlyList<ILipMorpher> morphers)\n {\n this.morphers = morphers;\n }\n void ILipMorpher.MorphInto(LipSample sample)\n {",
"score": 0.8956045508384705
},
{
"filename": "Assets/Mochineko/FacialExpressions/Blink/CompositeEyelidMorpher.cs",
"retrieved_chunk": " /// <summary>\n /// Creates a new instance of <see cref=\"CompositeEyelidMorpher\"/>.\n /// </summary>\n /// <param name=\"morphers\">Composited morphers.</param>\n public CompositeEyelidMorpher(IReadOnlyList<IEyelidMorpher> morphers)\n {\n this.morphers = morphers;\n }\n void IEyelidMorpher.MorphInto(EyelidSample sample)\n {",
"score": 0.8809957504272461
},
{
"filename": "Assets/Mochineko/FacialExpressions/Emotion/SkinnedMeshEmotionMorpher.cs",
"retrieved_chunk": " public sealed class SkinnedMeshEmotionMorpher<TEmotion>\n : IEmotionMorpher<TEmotion>\n where TEmotion : Enum\n {\n private readonly SkinnedMeshRenderer skinnedMeshRenderer;\n private readonly IReadOnlyDictionary<TEmotion, int> indexMap;\n /// <summary>\n /// Creates a new instance of <see cref=\"SkinnedMeshEmotionMorpher{TEmotion}\"/>.\n /// </summary>\n /// <param name=\"skinnedMeshRenderer\">Target renderer.</param>",
"score": 0.8334184885025024
},
{
"filename": "Assets/Mochineko/FacialExpressions/LipSync/CompositeLipMorpher.cs",
"retrieved_chunk": "#nullable enable\nusing System.Collections.Generic;\nnamespace Mochineko.FacialExpressions.LipSync\n{\n /// <summary>\n /// Composition of some <see cref=\"Mochineko.FacialExpressions.LipSync.ILipMorpher\"/>s.\n /// </summary>\n public sealed class CompositeLipMorpher : ILipMorpher\n {\n private readonly IReadOnlyList<ILipMorpher> morphers;",
"score": 0.8124780654907227
},
{
"filename": "Assets/Mochineko/FacialExpressions/Emotion/AnimatorEmotionMorpher.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nusing UnityEngine;\nnamespace Mochineko.FacialExpressions.Emotion\n{\n /// <summary>\n /// A simple implementation of <see cref=\"IEmotionMorpher{TEmotion}\"/> for <see cref=\"Animator\"/>.\n /// </summary>\n public sealed class AnimatorEmotionMorpher<TEmotion>",
"score": 0.798385739326477
}
] | csharp | IEmotionMorpher<TEmotion>.MorphInto(EmotionSample<TEmotion> sample)
{ |
using HarmonyLib;
using UnityEngine;
namespace Ultrapain.Patches
{
class GrenadeParriedFlag : MonoBehaviour
{
public int parryCount = 1;
public bool registeredStyle = false;
public bool bigExplosionOverride = false;
public GameObject temporaryExplosion;
public GameObject temporaryBigExplosion;
public | GameObject weapon; |
public enum GrenadeType
{
Core,
Rocket,
}
public GrenadeType grenadeType;
}
class Punch_CheckForProjectile_Patch
{
static bool Prefix(Punch __instance, Transform __0, ref bool __result, ref bool ___hitSomething, Animator ___anim)
{
Grenade grn = __0.GetComponent<Grenade>();
if(grn != null)
{
if (grn.rocket && !ConfigManager.rocketBoostToggle.value)
return true;
if (!ConfigManager.grenadeBoostToggle.value)
return true;
MonoSingleton<TimeController>.Instance.ParryFlash();
___hitSomething = true;
grn.transform.LookAt(Camera.main.transform.position + Camera.main.transform.forward * 100.0f);
Rigidbody rb = grn.GetComponent<Rigidbody>();
rb.velocity = Vector3.zero;
rb.AddRelativeForce(Vector3.forward * Mathf.Max(Plugin.MinGrenadeParryVelocity, rb.velocity.magnitude), ForceMode.VelocityChange);
rb.velocity = grn.transform.forward * Mathf.Max(Plugin.MinGrenadeParryVelocity, rb.velocity.magnitude);
/*if (grn.rocket)
MonoSingleton<StyleHUD>.Instance.AddPoints(100, Plugin.StyleIDs.rocketBoost, MonoSingleton<GunControl>.Instance.currentWeapon, null);
else
MonoSingleton<StyleHUD>.Instance.AddPoints(100, Plugin.StyleIDs.fistfulOfNades, MonoSingleton<GunControl>.Instance.currentWeapon, null);
*/
GrenadeParriedFlag flag = grn.GetComponent<GrenadeParriedFlag>();
if (flag != null)
flag.parryCount += 1;
else
{
flag = grn.gameObject.AddComponent<GrenadeParriedFlag>();
flag.grenadeType = (grn.rocket) ? GrenadeParriedFlag.GrenadeType.Rocket : GrenadeParriedFlag.GrenadeType.Core;
flag.weapon = MonoSingleton<GunControl>.Instance.currentWeapon;
}
grn.rocketSpeed *= 1f + ConfigManager.rocketBoostSpeedMultiplierPerHit.value;
___anim.Play("Hook", 0, 0.065f);
__result = true;
return false;
}
return true;
}
}
class Grenade_Explode_Patch1
{
static bool Prefix(Grenade __instance, ref bool __2, ref bool __1, ref bool ___exploded)
{
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return true;
if (__instance.rocket)
{
bool rocketParried = flag != null;
bool rocketHitGround = __1;
flag.temporaryBigExplosion = GameObject.Instantiate(__instance.superExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.superExplosion = flag.temporaryBigExplosion;
foreach (Explosion e in __instance.superExplosion.GetComponentsInChildren<Explosion>())
{
e.speed *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
e.damage *= (int)(1f + ConfigManager.rocketBoostDamageMultiplierPerHit.value * flag.parryCount);
e.maxSize *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
}
flag.temporaryExplosion = GameObject.Instantiate(__instance.explosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.explosion = flag.temporaryExplosion;
if (rocketParried/* && rocketHitGround*/)
{
if(!rocketHitGround || ConfigManager.rocketBoostAlwaysExplodesToggle.value)
__1 = false;
foreach(Explosion e in (__2) ? flag.temporaryBigExplosion.GetComponentsInChildren<Explosion>() : flag.temporaryExplosion.GetComponentsInChildren<Explosion>())
{
GrenadeParriedFlag fFlag = e.gameObject.AddComponent<GrenadeParriedFlag>();
fFlag.weapon = flag.weapon;
fFlag.grenadeType = GrenadeParriedFlag.GrenadeType.Rocket;
fFlag.parryCount = flag.parryCount;
break;
}
}
foreach (Explosion e in __instance.explosion.GetComponentsInChildren<Explosion>())
{
e.speed *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
e.damage *= (int)(1f + ConfigManager.rocketBoostDamageMultiplierPerHit.value * flag.parryCount);
e.maxSize *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
}
}
else
{
if (flag != null/* && flag.bigExplosionOverride*/)
{
__2 = true;
GameObject explosion = GameObject.Instantiate(__instance.superExplosion);
foreach(Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.damage = (int)(exp.damage * ConfigManager.grenadeBoostDamageMultiplier.value);
exp.maxSize *= ConfigManager.grenadeBoostSizeMultiplier.value;
exp.speed *= ConfigManager.grenadeBoostSizeMultiplier.value;
}
__instance.superExplosion = explosion;
flag.temporaryBigExplosion = explosion;
}
}
return true;
}
static void Postfix(Grenade __instance, ref bool ___exploded)
{
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return;
if (__instance.rocket)
{
if (flag.temporaryExplosion != null)
{
GameObject.Destroy(flag.temporaryExplosion);
flag.temporaryExplosion = null;
}
if (flag.temporaryBigExplosion != null)
{
GameObject.Destroy(flag.temporaryBigExplosion);
flag.temporaryBigExplosion = null;
}
}
else
{
if (flag.temporaryBigExplosion != null)
{
GameObject.Destroy(flag.temporaryBigExplosion);
flag.temporaryBigExplosion = null;
}
}
}
}
class Grenade_Collision_Patch
{
static float lastTime = 0;
static bool Prefix(Grenade __instance, Collider __0)
{
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return true;
//if (!Plugin.ultrapainDifficulty || !ConfigManager.playerTweakToggle.value || !ConfigManager.grenadeBoostToggle.value)
// return true;
if (__0.gameObject.layer != 14 && __0.gameObject.layer != 20)
{
EnemyIdentifierIdentifier enemyIdentifierIdentifier;
if ((__0.gameObject.layer == 11 || __0.gameObject.layer == 10) && __0.TryGetComponent<EnemyIdentifierIdentifier>(out enemyIdentifierIdentifier) && enemyIdentifierIdentifier.eid)
{
if (enemyIdentifierIdentifier.eid.enemyType != EnemyType.MaliciousFace && flag.grenadeType == GrenadeParriedFlag.GrenadeType.Core && (Time.time - lastTime >= 0.25f || lastTime < 0))
{
lastTime = Time.time;
flag.bigExplosionOverride = true;
MonoSingleton<StyleHUD>.Instance.AddPoints(ConfigManager.grenadeBoostStylePoints.value, ConfigManager.grenadeBoostStyleText.guid, MonoSingleton<GunControl>.Instance.currentWeapon, null);
}
}
}
return true;
}
}
class Explosion_Collide_Patch
{
static float lastTime = 0;
static bool Prefix(Explosion __instance, Collider __0)
{
GrenadeParriedFlag flag = __instance.gameObject.GetComponent<GrenadeParriedFlag>();
if (flag == null || flag.registeredStyle)
return true;
if (!flag.registeredStyle && __0.gameObject.tag != "Player" && (__0.gameObject.layer == 10 || __0.gameObject.layer == 11)
&& __instance.canHit != AffectedSubjects.PlayerOnly)
{
EnemyIdentifierIdentifier componentInParent = __0.GetComponentInParent<EnemyIdentifierIdentifier>();
if(flag.grenadeType == GrenadeParriedFlag.GrenadeType.Rocket && componentInParent != null && componentInParent.eid != null && !componentInParent.eid.blessed && !componentInParent.eid.dead && (Time.time - lastTime >= 0.25f || lastTime < 0))
{
flag.registeredStyle = true;
lastTime = Time.time;
MonoSingleton<StyleHUD>.Instance.AddPoints(ConfigManager.rocketBoostStylePoints.value, ConfigManager.rocketBoostStyleText.guid, flag.weapon, null, flag.parryCount);
}
}
return true;
}
}
}
| Ultrapain/Patches/Parry.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/OrbitalStrike.cs",
"retrieved_chunk": " }\n class OrbitalExplosionInfo : MonoBehaviour\n {\n public bool active = true;\n public string id;\n public int points;\n }\n class Grenade_Explode\n {\n class StateInfo",
"score": 0.9274425506591797
},
{
"filename": "Ultrapain/Patches/V2Common.cs",
"retrieved_chunk": " return true;\n }\n }\n class V2CommonRevolverBulletSharp : MonoBehaviour\n {\n public int reflectionCount = 2;\n public float autoAimAngle = 30f;\n public Projectile proj;\n public float speed = 350f;\n public bool hasTargetPoint = false;",
"score": 0.8945382833480835
},
{
"filename": "Ultrapain/Patches/OrbitalStrike.cs",
"retrieved_chunk": " {\n public CoinChainList chainList;\n public bool isOrbitalRay = false;\n public bool exploded = false;\n public float activasionDistance;\n }\n public class Coin_Start\n {\n static void Postfix(Coin __instance)\n {",
"score": 0.8915731310844421
},
{
"filename": "Ultrapain/Patches/CommonComponents.cs",
"retrieved_chunk": " public float superSize = 1f;\n public float superSpeed = 1f;\n public float superDamage = 1f;\n public int superPlayerDamageOverride = -1;\n struct StateInfo\n {\n public GameObject tempHarmless;\n public GameObject tempNormal;\n public GameObject tempSuper;\n public StateInfo()",
"score": 0.883702278137207
},
{
"filename": "Ultrapain/Patches/Virtue.cs",
"retrieved_chunk": " }\n }\n class VirtueFlag : MonoBehaviour\n {\n public AudioSource lighningBoltSFX;\n public GameObject ligtningBoltAud;\n public Transform windupObj;\n private EnemyIdentifier eid;\n public Drone virtue;\n public void Awake()",
"score": 0.8788962364196777
}
] | csharp | GameObject weapon; |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WAGIapp.AI.AICommands
{
internal class SearchWebCommand : Command
{
public override string Name => "search-web";
public override string Description => "Searches the web and returns a list of links and descriptions";
public override string | Format => "search-web | querry"; |
public override async Task<string> Execute(Master caller, string[] args)
{
if (args.Length < 2)
return "error! not enough parameters";
string web = await Utils.WebResult("https://html.duckduckgo.com/html/?q=" + args[1],true);
List<string> headers = new List<string>();
List<string> urls = new List<string>();
List<string> descritpions = new List<string>();
int i = 0;
while (true)
{
int tagStart = web.IndexOf("<a rel=\"nofollow\" class=\"result__a\"", i);
if (tagStart == -1)
break;
int tagEnd = web.IndexOf(">", tagStart);
int blockEnd = web.IndexOf("</a>", tagEnd);
headers.Add(web.Substring(tagEnd + 1, blockEnd - tagEnd - 1));
i = blockEnd;
}
i = 0;
while (true)
{
int tagStart = web.IndexOf("<a class=\"result__url\"", i);
if (tagStart == -1)
break;
int tagEnd = web.IndexOf(">", tagStart);
int blockEnd = web.IndexOf("</a>", tagEnd);
urls.Add(web.Substring(tagEnd + 1, blockEnd - tagEnd - 1));
i = blockEnd;
}
i = 0;
while (true)
{
int tagStart = web.IndexOf("<a class=\"result__snip", i);
if (tagStart == -1)
break;
int tagEnd = web.IndexOf(">", tagStart);
int blockEnd = web.IndexOf("</a>", tagEnd);
descritpions.Add(web.Substring(tagEnd + 1, blockEnd - tagEnd - 1));
i = blockEnd;
}
string output = "";
for (int j = 0; j < headers.Count; j++)
{
headers[j] = Utils.CleanHtmlInput(headers[j]);
urls[j] = Utils.CleanHtmlInput(urls[j]);
descritpions[j] = Utils.CleanHtmlInput(descritpions[j]);
}
i = 0;
while (output.Split(" ").Length < 800 && i < headers.Count)
{
output += (i + 1) + ". " + headers[i] + "\n";
output += "[" + urls[i] + "]\n";
output += descritpions[i] + "\n\n";
i++;
}
return output;
}
}
}
| WAGIapp/AI/AICommands/SearchWebCommand.cs | Woltvint-WAGI-d808927 | [
{
"filename": "WAGIapp/AI/AICommands/WriteLineCommand.cs",
"retrieved_chunk": "namespace WAGIapp.AI.AICommands\n{\n internal class WriteLineCommand : Command\n {\n public override string Name => \"write-line\";\n public override string Description => \"writes the given text to the line number\";\n public override string Format => \"write-line | line number | text\";\n public override async Task<string> Execute(Master caller, string[] args)\n {\n if (args.Length < 3)",
"score": 0.8878240585327148
},
{
"filename": "WAGIapp/AI/AICommands/RemoveLineCommand.cs",
"retrieved_chunk": "namespace WAGIapp.AI.AICommands\n{\n internal class RemoveLineCommand : Command\n {\n public override string Name => \"remove-line\";\n public override string Description => \"deletes a line from the script\";\n public override string Format => \"remove-line | line number\";\n public override async Task<string> Execute(Master caller, string[] args)\n {\n if (args.Length < 2)",
"score": 0.8845827579498291
},
{
"filename": "WAGIapp/AI/AICommands/Command.cs",
"retrieved_chunk": "namespace WAGIapp.AI.AICommands\n{\n internal abstract class Command\n {\n public abstract string Name { get; }\n public abstract string Description { get; }\n public abstract string Format { get; }\n public abstract Task<string> Execute(Master caller, string[] args);\n }\n}",
"score": 0.8701906204223633
},
{
"filename": "WAGIapp/AI/LogAction.cs",
"retrieved_chunk": "using MudBlazor;\nnamespace WAGIapp.AI\n{\n public class LogAction\n {\n public string Title { get; set; } = \"\";\n public string Icon { get; set; } = \"\";\n public string Text { get; set; } = \"\";\n public bool Last { get; set; } = false;\n public const string InfoIcon = Icons.Material.Filled.Info;",
"score": 0.8428096771240234
},
{
"filename": "WAGIapp/AI/Commands.cs",
"retrieved_chunk": "using WAGIapp.AI.AICommands;\nnamespace WAGIapp.AI\n{\n internal class Commands\n {\n private static Dictionary<string, Command> commands;\n static Commands()\n {\n commands = new Dictionary<string, Command>();\n Command c;",
"score": 0.8413048386573792
}
] | csharp | Format => "search-web | querry"; |
using JdeJabali.JXLDataTableExtractor.Configuration;
using JdeJabali.JXLDataTableExtractor.DataExtraction;
using JdeJabali.JXLDataTableExtractor.Exceptions;
using JdeJabali.JXLDataTableExtractor.JXLExtractedData;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
namespace JdeJabali.JXLDataTableExtractor
{
public class DataTableExtractor :
IDataTableExtractorConfiguration,
IDataTableExtractorWorkbookConfiguration,
IDataTableExtractorSearchConfiguration,
IDataTableExtractorWorksheetConfiguration
{
private bool _readAllWorksheets;
private int _searchLimitRow;
private int _searchLimitColumn;
private readonly List<string> _workbooks = new List<string>();
private readonly List<int> _worksheetIndexes = new List<int>();
private readonly List<string> _worksheets = new List<string>();
private readonly List<HeaderToSearch> _headersToSearch = new List<HeaderToSearch>();
private HeaderToSearch _headerToSearch;
private DataReader _reader;
private DataTableExtractor()
{
}
public static IDataTableExtractorConfiguration Configure()
{
return new DataTableExtractor();
}
public IDataTableExtractorWorkbookConfiguration Workbook(string workbook)
{
if (string.IsNullOrEmpty(workbook))
{
throw new ArgumentException($"{nameof(workbook)} cannot be null or empty.");
}
// You can't add more than one workbook anyway, so there is no need to check for duplicates.
// This would imply that there is a configuration for each workbook.
_workbooks.Add(workbook);
return this;
}
public IDataTableExtractorWorkbookConfiguration Workbooks(string[] workbooks)
{
if (workbooks is null)
{
throw new ArgumentNullException($"{nameof(workbooks)} cannot be null.");
}
foreach (string workbook in workbooks)
{
if (_workbooks.Contains(workbook))
{
throw new DuplicateWorkbookException("Cannot search for more than one workbook with the same name: " +
$@"""{workbook}"".");
}
_workbooks.Add(workbook);
}
return this;
}
public | IDataTableExtractorSearchConfiguration SearchLimits(int searchLimitRow, int searchLimitColumn)
{ |
_searchLimitRow = searchLimitRow;
_searchLimitColumn = searchLimitColumn;
return this;
}
public IDataTableExtractorSearchConfiguration Worksheet(int worksheetIndex)
{
if (worksheetIndex < 0)
{
throw new ArgumentException($"{nameof(worksheetIndex)} cannot be less than zero.");
}
if (_worksheetIndexes.Contains(worksheetIndex))
{
throw new ArgumentException("Cannot search for more than one worksheet with the same name: " +
$@"""{worksheetIndex}"".");
}
_worksheetIndexes.Add(worksheetIndex);
return this;
}
public IDataTableExtractorSearchConfiguration Worksheets(int[] worksheetIndexes)
{
if (worksheetIndexes is null)
{
throw new ArgumentException($"{nameof(worksheetIndexes)} cannot be null or empty.");
}
_worksheetIndexes.AddRange(worksheetIndexes);
return this;
}
public IDataTableExtractorSearchConfiguration Worksheet(string worksheet)
{
if (string.IsNullOrEmpty(worksheet))
{
throw new ArgumentException($"{nameof(worksheet)} cannot be null or empty.");
}
if (_worksheets.Contains(worksheet))
{
throw new ArgumentException("Cannot search for more than one worksheet with the same name: " +
$@"""{worksheet}"".");
}
_worksheets.Add(worksheet);
return this;
}
public IDataTableExtractorSearchConfiguration Worksheets(string[] worksheets)
{
if (worksheets is null)
{
throw new ArgumentException($"{nameof(worksheets)} cannot be null or empty.");
}
_worksheets.AddRange(worksheets);
return this;
}
public IDataTableExtractorWorksheetConfiguration ReadOnlyTheIndicatedSheets()
{
_readAllWorksheets = false;
if (_worksheetIndexes.Count == 0 && _worksheets.Count == 0)
{
throw new InvalidOperationException("No worksheets selected.");
}
return this;
}
public IDataTableExtractorWorksheetConfiguration ReadAllWorksheets()
{
_readAllWorksheets = true;
return this;
}
IDataTableExtractorWorksheetConfiguration IDataTableColumnsToSearch.ColumnHeader(string columnHeader)
{
if (string.IsNullOrEmpty(columnHeader))
{
throw new ArgumentException($"{nameof(columnHeader)} cannot be null or empty.");
}
if (_headersToSearch.FirstOrDefault(h => h.ColumnHeaderName == columnHeader) != null)
{
throw new DuplicateColumnException("Cannot search for more than one column header with the same name: " +
$@"""{columnHeader}"".");
}
_headerToSearch = new HeaderToSearch()
{
ColumnHeaderName = columnHeader,
};
_headersToSearch.Add(_headerToSearch);
return this;
}
IDataTableExtractorWorksheetConfiguration IDataTableColumnsToSearch.ColumnIndex(int columnIndex)
{
if (columnIndex < 0)
{
throw new ArgumentException($"{nameof(columnIndex)} cannot be less than zero.");
}
if (_headersToSearch.FirstOrDefault(h => h.ColumnIndex == columnIndex) != null)
{
throw new DuplicateColumnException("Cannot search for more than one column with the same index: " +
$@"""{columnIndex}"".");
}
_headerToSearch = new HeaderToSearch()
{
ColumnIndex = columnIndex,
};
_headersToSearch.Add(_headerToSearch);
return this;
}
IDataTableExtractorWorksheetConfiguration IDataTableColumnsToSearch.CustomColumnHeaderMatch(Func<string, bool> conditional)
{
if (conditional is null)
{
throw new ArgumentNullException("Conditional cannot be null.");
}
_headerToSearch = new HeaderToSearch()
{
ConditionalToReadColumnHeader = conditional,
};
_headersToSearch.Add(_headerToSearch);
return this;
}
IDataTableExtractorWorksheetConfiguration IDataTableExtractorColumnConfiguration.ConditionToExtractRow(Func<string, bool> conditional)
{
if (conditional is null)
{
throw new ArgumentNullException("Conditional cannot be null.");
}
if (_headerToSearch is null)
{
throw new InvalidOperationException(nameof(_headerToSearch));
}
_headerToSearch.ConditionalToReadRow = conditional;
return this;
}
public List<JXLWorkbookData> GetWorkbooksData()
{
_reader = new DataReader()
{
Workbooks = _workbooks,
SearchLimitRow = _searchLimitRow,
SearchLimitColumn = _searchLimitColumn,
WorksheetIndexes = _worksheetIndexes,
Worksheets = _worksheets,
ReadAllWorksheets = _readAllWorksheets,
HeadersToSearch = _headersToSearch,
};
return _reader.GetWorkbooksData();
}
public List<JXLExtractedRow> GetExtractedRows()
{
_reader = new DataReader()
{
Workbooks = _workbooks,
SearchLimitRow = _searchLimitRow,
SearchLimitColumn = _searchLimitColumn,
WorksheetIndexes = _worksheetIndexes,
Worksheets = _worksheets,
ReadAllWorksheets = _readAllWorksheets,
HeadersToSearch = _headersToSearch,
};
return _reader.GetJXLExtractedRows();
}
public DataTable GetDataTable()
{
_reader = new DataReader()
{
Workbooks = _workbooks,
SearchLimitRow = _searchLimitRow,
SearchLimitColumn = _searchLimitColumn,
WorksheetIndexes = _worksheetIndexes,
Worksheets = _worksheets,
ReadAllWorksheets = _readAllWorksheets,
HeadersToSearch = _headersToSearch,
};
return _reader.GetDataTable();
}
}
} | JdeJabali.JXLDataTableExtractor/DataTableExtractor.cs | JdeJabali-JXLDataTableExtractor-90a12f4 | [
{
"filename": "JdeJabali.JXLDataTableExtractor/DataExtraction/DataReader.cs",
"retrieved_chunk": " worksheetData.WorksheetName = worksheet.Name;\n }\n catch\n {\n throw new InvalidOperationException($@\"Error reading worksheet: \"\"{worksheet.Name}\"\" \" +\n $@\"in workbook: \"\"{workbook}\"\"\");\n }\n if (worksheetData != null)\n {\n worksheetsData.Add(worksheetData);",
"score": 0.8350793719291687
},
{
"filename": "JdeJabali.JXLDataTableExtractor/DataExtraction/DataReader.cs",
"retrieved_chunk": " GetHeadersCoordinates(sheet);\n if (!AreHeadersInTheSameRow())\n {\n throw new InvalidOperationException(\n $\"The headers to look for found in {worksheetData.WorksheetName} do not match in the same row. Cannot continue.\");\n }\n worksheetData = GetWorksheetData(sheet);\n return worksheetData;\n }\n private JXLWorksheetData GetWorksheetData(ExcelWorksheet sheet)",
"score": 0.8303349614143372
},
{
"filename": "JdeJabali.JXLDataTableExtractor/DataExtraction/DataReader.cs",
"retrieved_chunk": " {\n throw new InvalidOperationException($@\"Error reading worksheet by index: \"\"{worksheetIndex}\"\" \" +\n $@\"in workbook: \"\"{workbook}\"\". {ex.Message}\");\n }\n if (worksheetData != null)\n {\n worksheetsData.Add(worksheetData);\n }\n }\n return worksheetsData;",
"score": 0.8295843601226807
},
{
"filename": "JdeJabali.JXLDataTableExtractor/DataExtraction/DataReaderHelpers.cs",
"retrieved_chunk": " throw new IndexOutOfRangeException($@\"Worksheet index not found: \"\"{index}\"\" in \"\"{workbook}\"\".\");\n }\n return worksheet;\n }\n public static ExcelWorksheet GetWorksheetByName(string worksheetName, string workbook, ExcelPackage excel)\n {\n ExcelWorksheet worksheet = excel.Workbook.Worksheets\n .AsEnumerable()\n .FirstOrDefault(ws => ws.Name == worksheetName);\n if (worksheet is null)",
"score": 0.8165481090545654
},
{
"filename": "JdeJabali.JXLDataTableExtractor/DataExtraction/DataReader.cs",
"retrieved_chunk": " }\n workbookData.WorksheetsData.AddRange(worksheetsData);\n workbooksData.Add(workbookData);\n }\n }\n return workbooksData;\n }\n private Func<string, ExcelPackage, List<JXLWorksheetData>> ResolveGettingWorksheetsMethod()\n {\n if (ReadAllWorksheets)",
"score": 0.8104711174964905
}
] | csharp | IDataTableExtractorSearchConfiguration SearchLimits(int searchLimitRow, int searchLimitColumn)
{ |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace RosettaStone.Core
{
public class ResultSet
{
#region Public-Members
public string Key { get; set; } = null;
public string Left { get; set; } = null;
public string Right { get; set; } = null;
public | VendorMetadata Vendor { | get; set; } = null;
public List<VendorMetadata> Vendors { get; set; } = null;
public CodecMetadata Codec { get; set; } = null;
public List<CodecMetadata> Codecs { get; set; } = null;
#endregion
#region Private-Members
#endregion
#region Constructors-and-Factories
public ResultSet()
{
}
#endregion
#region Public-Methods
#endregion
#region Private-Methods
#endregion
}
}
| src/RosettaStone.Core/ResultSet.cs | jchristn-RosettaStone-898982c | [
{
"filename": "src/RosettaStone.Core/ApiErrorResponse.cs",
"retrieved_chunk": " public int StatusCode { get; set; } = 200;\n public string Message { get; set; } = null;\n public string Context { get; set; } = null;\n public Exception Exception { get; set; } = null;\n #endregion\n #region Private-Members\n #endregion\n #region Constructors-and-Factories\n public ApiErrorResponse()\n {",
"score": 0.91339111328125
},
{
"filename": "src/RosettaStone.Core/Settings.cs",
"retrieved_chunk": " public string DnsHostname { get; set; } = \"localhost\";\n public int Port { get; set; } = 8000;\n public bool Ssl { get; set; } = false;\n public string AdminApiKeyHeader { get; set; } = \"x-api-key\";\n public string AdminApiKey { get; set; } = \"rosettastoneadmin\";\n public WebserverSettings()\n {\n }\n }\n public class LoggingSettings",
"score": 0.8774515390396118
},
{
"filename": "src/RosettaStone.Core/CodecMetadata.cs",
"retrieved_chunk": " public int? EditDistance { get; set; } = null;\n #endregion\n #region Private-Members\n #endregion\n #region Constructors-and-Factories\n public CodecMetadata()\n {\n }\n public CodecMetadata(string key, string name, string version, string uri)\n {",
"score": 0.8650984764099121
},
{
"filename": "src/RosettaStone.Core/VendorMetadata.cs",
"retrieved_chunk": " [Column(\"isassigned\", false, DataTypes.Boolean, false)]\n public bool IsAssigned { get; set; } = false;\n [Column(\"createdutc\", false, DataTypes.DateTime, false)]\n public DateTime CreatedUtc { get; set; } = DateTime.UtcNow;\n [Column(\"lastmodifiedutc\", false, DataTypes.DateTime, 32, false)]\n public DateTime LastModifiedUtc { get; set; } = DateTime.UtcNow;\n public int? EditDistance { get; set; } = null;\n #endregion\n #region Private-Members\n #endregion",
"score": 0.8611635565757751
},
{
"filename": "src/RosettaStone.Core/Settings.cs",
"retrieved_chunk": " {\n public string SyslogServerIp { get; set; } = \"127.0.0.1\";\n public int SyslogServerPort { get; set; } = 514;\n public int MinimumSeverity { get; set; } = 0;\n public bool ConsoleLogging { get; set; } = true;\n public bool ConsoleColors { get; set; } = true;\n public string LogDirectory { get; set; } = \"./logs/\";\n public string LogFilename { get; set; } = \"rosettastone.log\";\n public LoggingSettings()\n {",
"score": 0.8585529327392578
}
] | csharp | VendorMetadata Vendor { |
using Microsoft.EntityFrameworkCore;
using Ryan.EntityFrameworkCore.Builder;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Ryan.EntityFrameworkCore.Proxy
{
/// <inheritdoc cref="IEntityProxyGenerator"/>
public class EntityProxyGenerator : IEntityProxyGenerator
{
/// <inheritdoc cref="IEntityModelBuilderGenerator"/>
public IEntityModelBuilderGenerator EntityModelBuilderGenerator { get; }
/// <inheritdoc cref="IEntityImplementationDictionaryGenerator"/>
public IEntityImplementationDictionaryGenerator EntityImplementationDictionaryGenerator { get; }
/// <summary>
/// 创建实体代理
/// </summary>
public EntityProxyGenerator(
| IEntityModelBuilderGenerator entityModelBuilderGenerator
, IEntityImplementationDictionaryGenerator entityImplementationDictionaryGenerator)
{ |
EntityModelBuilderGenerator = entityModelBuilderGenerator;
EntityImplementationDictionaryGenerator = entityImplementationDictionaryGenerator;
}
/// <inheritdoc/>
public EntityProxy Create(object entity, EntityProxyType type, DbContext dbContext)
{
if (type == EntityProxyType.NonQuery)
{
var builder = (EntityModelBuilderGenerator.Create(entity.GetType()) as IEntityModelBuilder)!;
var visitors = builder.GetExpressionVisitors().ToList();
foreach (var visitor in visitors)
{
visitor.Visit(entity);
}
var pairs = visitors.Select(x => new KeyValuePair<string, string?>(x.MemberExpression.Member.Name, x.Values.FirstOrDefault()));
var dictionary = new Dictionary<string, string>(pairs!);
var tableName = builder.GetTableName(dictionary);
var ei = EntityImplementationDictionaryGenerator.Create(entity.GetType())[tableName];
var entityImplementation = Activator.CreateInstance(ei.ImplementationType)!;
return new EntityProxy(entity, entityImplementation, type, dbContext);
}
return new EntityProxy(entity, null, type, dbContext);
}
}
}
| src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/EntityProxyGenerator.cs | c-y-r-Ryan.EntityFrameworkCore.Shard-f15124c | [
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Builder/EntityModelBuilderAccessorGenerator.cs",
"retrieved_chunk": " /// <summary>\n /// 创建实体模型构建访问器\n /// </summary>\n public EntityModelBuilderAccessorGenerator(\n IEntityModelBuilderGenerator entityModelBuilderGenerator\n , IEntityImplementationDictionaryGenerator implementationDictionaryGenerator)\n {\n EntityModelBuilderGenerator = entityModelBuilderGenerator;\n ImplementationDictionaryGenerator = implementationDictionaryGenerator;\n MemoryCache = new InternalMemoryCache();",
"score": 0.9142502546310425
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Expressions/ExpressionImplementationFinder.cs",
"retrieved_chunk": " /// <summary>\n /// 访问器生成器\n /// </summary>\n public IEntityModelBuilderAccessorGenerator EntityModelBuilderAccessorGenerator { get; }\n /// <summary>\n /// 创建表达式实现查询器\n /// </summary>\n public ExpressionImplementationFinder(IEntityModelBuilderAccessorGenerator entityModelBuilderAccessorGenerator)\n {\n EntityModelBuilderAccessorGenerator = entityModelBuilderAccessorGenerator;",
"score": 0.9103726148605347
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Builder/EntityModelBuilderAccessorGenerator.cs",
"retrieved_chunk": " /// </summary>\n public IEntityModelBuilderGenerator EntityModelBuilderGenerator { get; }\n /// <summary>\n /// 实体实现字典生成器\n /// </summary>\n public IEntityImplementationDictionaryGenerator ImplementationDictionaryGenerator { get; }\n /// <summary>\n /// 缓存\n /// </summary>\n public IMemoryCache MemoryCache { get; }",
"score": 0.9087051153182983
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Builder/EntityShardConfiguration.cs",
"retrieved_chunk": " /// 动态类型创建\n /// </summary>\n public IDynamicTypeGenerator DynamicTypeGenerator { get; }\n /// <summary>\n /// 创建实体分表配置\n /// </summary>\n public EntityShardConfiguration(\n IEntityImplementationDictionaryGenerator entityImplementationDictionaryGenerator\n , IDynamicTypeGenerator dynamicTypeGenerator)\n {",
"score": 0.9072489142417908
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Builder/EntityModelBuilderAccessor.cs",
"retrieved_chunk": " /// </summary>\n public object EntityModelBuilder { get; }\n /// <summary>\n /// 访问器\n /// </summary>\n public Action<Type, ModelBuilder> Accessor { get; protected set; }\n /// <summary>\n /// 创建实体模型构建访问器\n /// </summary>\n public EntityModelBuilderAccessor(Type entityType, EntityImplementationDictionary dictionary, object entityModelBuilder)",
"score": 0.887819230556488
}
] | csharp | IEntityModelBuilderGenerator entityModelBuilderGenerator
, IEntityImplementationDictionaryGenerator entityImplementationDictionaryGenerator)
{ |
#nullable enable
using System;
using System.IO;
using System.Threading;
using Cysharp.Threading.Tasks;
using Mochineko.ChatGPT_API;
using Mochineko.FacialExpressions.Blink;
using Mochineko.FacialExpressions.Emotion;
using Mochineko.FacialExpressions.Extensions.VRM;
using Mochineko.FacialExpressions.LipSync;
using Mochineko.FacialExpressions.Samples;
using Mochineko.LLMAgent.Chat;
using Mochineko.LLMAgent.Emotion;
using Mochineko.LLMAgent.Memory;
using Mochineko.LLMAgent.Speech;
using Mochineko.LLMAgent.Summarization;
using Mochineko.Relent.Extensions.NewtonsoftJson;
using Mochineko.Relent.Result;
using Mochineko.RelentStateMachine;
using Mochineko.VOICEVOX_API.QueryCreation;
using UnityEngine;
using UniVRM10;
using VRMShaders;
namespace Mochineko.LLMAgent.Operation
{
internal sealed class DemoOperator : MonoBehaviour
{
[SerializeField] private Model model = Model.Turbo;
[SerializeField, TextArea] private string prompt = string.Empty;
[SerializeField, TextArea] private string defaultConversations = string.Empty;
[SerializeField, TextArea] private string message = string.Empty;
[SerializeField] private int speakerID;
[SerializeField] private string vrmAvatarPath = string.Empty;
[SerializeField] private float emotionFollowingTime = 1f;
[SerializeField] private float emotionWeight = 1f;
[SerializeField] private AudioSource? audioSource = null;
[SerializeField] private RuntimeAnimatorController? animatorController = null;
private IChatMemoryStore? store;
private LongTermChatMemory? memory;
internal LongTermChatMemory? Memory => memory;
private ChatCompletion? chatCompletion;
private ChatCompletion? stateCompletion;
private VoiceVoxSpeechSynthesis? speechSynthesis;
private IFiniteStateMachine< | AgentEvent, AgentContext>? agentStateMachine; |
private async void Start()
{
await SetupAgentAsync(this.GetCancellationTokenOnDestroy());
}
private async void Update()
{
if (agentStateMachine == null)
{
return;
}
var updateResult = await agentStateMachine
.UpdateAsync(this.GetCancellationTokenOnDestroy());
if (updateResult is IFailureResult updateFailure)
{
Debug.LogError($"Failed to update agent state machine because -> {updateFailure.Message}.");
}
}
private void OnDestroy()
{
agentStateMachine?.Dispose();
}
private async UniTask SetupAgentAsync(CancellationToken cancellationToken)
{
if (audioSource == null)
{
throw new NullReferenceException(nameof(audioSource));
}
if (animatorController == null)
{
throw new NullReferenceException(nameof(animatorController));
}
var apiKeyPath = Path.Combine(
Application.dataPath,
"Mochineko/LLMAgent/Operation/OpenAI_API_Key.txt");
var apiKey = await File.ReadAllTextAsync(apiKeyPath, cancellationToken);
if (string.IsNullOrEmpty(apiKey))
{
throw new Exception($"[LLMAgent.Operation] Loaded API Key is empty from path:{apiKeyPath}");
}
store = new NullChatMemoryStore();
memory = await LongTermChatMemory.InstantiateAsync(
maxShortTermMemoriesTokenLength: 1000,
maxBufferMemoriesTokenLength: 1000,
apiKey,
model,
store,
cancellationToken);
chatCompletion = new ChatCompletion(
apiKey,
model,
prompt + PromptTemplate.MessageResponseWithEmotion,
memory);
if (!string.IsNullOrEmpty(defaultConversations))
{
var conversationsDeserializeResult = RelentJsonSerializer
.Deserialize<ConversationCollection>(defaultConversations);
if (conversationsDeserializeResult is ISuccessResult<ConversationCollection> successResult)
{
for (var i = 0; i < successResult.Result.Conversations.Count; i++)
{
await memory.AddMessageAsync(
successResult.Result.Conversations[i],
cancellationToken);
}
}
else if (conversationsDeserializeResult is IFailureResult<ConversationCollection> failureResult)
{
Debug.LogError(
$"[LLMAgent.Operation] Failed to deserialize default conversations because -> {failureResult.Message}");
}
}
speechSynthesis = new VoiceVoxSpeechSynthesis(speakerID);
var binary = await File.ReadAllBytesAsync(
vrmAvatarPath,
cancellationToken);
var instance = await LoadVRMAsync(
binary,
cancellationToken);
var lipMorpher = new VRMLipMorpher(instance.Runtime.Expression);
var lipAnimator = new FollowingLipAnimator(lipMorpher);
var emotionMorpher = new VRMEmotionMorpher(instance.Runtime.Expression);
var emotionAnimator = new ExclusiveFollowingEmotionAnimator<FacialExpressions.Emotion.Emotion>(
emotionMorpher,
followingTime: emotionFollowingTime);
var eyelidMorpher = new VRMEyelidMorpher(instance.Runtime.Expression);
var eyelidAnimator = new SequentialEyelidAnimator(eyelidMorpher);
var eyelidAnimationFrames =
ProbabilisticEyelidAnimationGenerator.Generate(
Eyelid.Both,
blinkCount: 20);
var agentContext = new AgentContext(
eyelidAnimator,
eyelidAnimationFrames,
lipMorpher,
lipAnimator,
audioSource,
emotionAnimator);
agentStateMachine = await AgentStateMachineFactory.CreateAsync(
agentContext,
cancellationToken);
instance
.GetComponent<Animator>()
.runtimeAnimatorController = animatorController;
}
// ReSharper disable once InconsistentNaming
private static async UniTask<Vrm10Instance> LoadVRMAsync(
byte[] binaryData,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
return await Vrm10.LoadBytesAsync(
bytes: binaryData,
canLoadVrm0X: true,
controlRigGenerationOption: ControlRigGenerationOption.Generate,
showMeshes: true,
awaitCaller: new RuntimeOnlyAwaitCaller(),
ct: cancellationToken
);
}
[ContextMenu(nameof(StartChatAsync))]
public void StartChatAsync()
{
ChatAsync(message, this.GetCancellationTokenOnDestroy())
.Forget();
}
public async UniTask ChatAsync(string message, CancellationToken cancellationToken)
{
if (chatCompletion == null)
{
throw new NullReferenceException(nameof(chatCompletion));
}
if (speechSynthesis == null)
{
throw new NullReferenceException(nameof(speechSynthesis));
}
if (agentStateMachine == null)
{
throw new NullReferenceException(nameof(agentStateMachine));
}
string chatResponse;
var chatResult = await chatCompletion.CompleteChatAsync(message, cancellationToken);
switch (chatResult)
{
case ISuccessResult<string> chatSuccess:
{
Debug.Log($"[LLMAgent.Operation] Complete chat message:{chatSuccess.Result}.");
chatResponse = chatSuccess.Result;
break;
}
case IFailureResult<string> chatFailure:
{
Debug.LogError($"[LLMAgent.Operation] Failed to complete chat because of {chatFailure.Message}.");
return;
}
default:
throw new ResultPatternMatchException(nameof(chatResult));
}
EmotionalMessage emotionalMessage;
var deserializeResult = RelentJsonSerializer.Deserialize<EmotionalMessage>(chatResponse);
switch (deserializeResult)
{
case ISuccessResult<EmotionalMessage> deserializeSuccess:
{
emotionalMessage = deserializeSuccess.Result;
break;
}
case IFailureResult<EmotionalMessage> deserializeFailure:
{
Debug.LogError(
$"[LLMAgent.Operation] Failed to deserialize emotional message:{chatResponse} because of {deserializeFailure.Message}.");
return;
}
default:
throw new ResultPatternMatchException(nameof(deserializeResult));
}
var emotion = EmotionConverter.ExcludeHighestEmotion(emotionalMessage.Emotion);
Debug.Log($"[LLMAgent.Operation] Exclude emotion:{emotion}.");
var synthesisResult = await speechSynthesis.SynthesisSpeechAsync(
HttpClientPool.PooledClient,
emotionalMessage.Message,
cancellationToken);
switch (synthesisResult)
{
case ISuccessResult<(AudioQuery query, AudioClip clip)> synthesisSuccess:
{
agentStateMachine.Context.SpeechQueue.Enqueue(new SpeechCommand(
synthesisSuccess.Result.query,
synthesisSuccess.Result.clip,
new EmotionSample<FacialExpressions.Emotion.Emotion>(emotion, emotionWeight)));
if (agentStateMachine.IsCurrentState<AgentIdleState>())
{
var sendEventResult = await agentStateMachine.SendEventAsync(
AgentEvent.BeginSpeaking,
cancellationToken);
if (sendEventResult is IFailureResult sendEventFailure)
{
Debug.LogError(
$"[LLMAgent.Operation] Failed to send event because of {sendEventFailure.Message}.");
}
}
break;
}
case IFailureResult<(AudioQuery query, AudioClip clip)> synthesisFailure:
{
Debug.Log(
$"[LLMAgent.Operation] Failed to synthesis speech because of {synthesisFailure.Message}.");
return;
}
default:
return;
}
}
}
} | Assets/Mochineko/LLMAgent/Operation/DemoOperator.cs | mochi-neko-llm-agent-sandbox-unity-6521c0b | [
{
"filename": "Assets/Mochineko/LLMAgent/Memory/LongTermChatMemory.cs",
"retrieved_chunk": " private readonly Queue<Message> shortTermMemories = new();\n internal IEnumerable<Message> ShortTermMemories => shortTermMemories.ToArray();\n private readonly Queue<Message> bufferMemories = new();\n internal IEnumerable<Message> BufferMemories => bufferMemories.ToArray();\n private readonly Summarizer summarizer;\n private readonly IChatMemoryStore store;\n private Message summary;\n internal Message Summary => summary;\n private readonly object lockObject = new();\n public static async UniTask<LongTermChatMemory> InstantiateAsync(",
"score": 0.8429788947105408
},
{
"filename": "Assets/Mochineko/KoeiromapAPI.Samples/KoeiromapAPISample.cs",
"retrieved_chunk": " [SerializeField] private Style style;\n [SerializeField] private AudioSource? audioSource;\n private static readonly HttpClient HttpClient = new();\n private IPolicy<Stream>? policy;\n private void Awake()\n {\n Assert.IsNotNull(audioSource);\n policy = PolicyFactory.BuildPolicy();\n }\n [ContextMenu(nameof(Synthesis))]",
"score": 0.8330643773078918
},
{
"filename": "Assets/Mochineko/LLMAgent/Summarization/Summarizer.cs",
"retrieved_chunk": " public sealed class Summarizer\n {\n private readonly Model model;\n private readonly TikToken tikToken;\n private readonly RelentChatCompletionAPIConnection connection;\n private readonly IChatMemory simpleChatMemory = new SimpleChatMemory();\n private readonly IPolicy<ChatCompletionResponseBody> policy;\n private readonly string summary = string.Empty;\n private const int MaxSummaryTokenLength = 2000;\n public Summarizer(",
"score": 0.8271520137786865
},
{
"filename": "Assets/Mochineko/LLMAgent/Chat/ChatCompletion.cs",
"retrieved_chunk": "{\n public sealed class ChatCompletion\n {\n private readonly Model model;\n private readonly IChatMemory memory;\n private readonly RelentChatCompletionAPIConnection connection;\n private readonly IPolicy<ChatCompletionResponseBody> policy;\n public ChatCompletion(\n string apiKey,\n Model model,",
"score": 0.8244751691818237
},
{
"filename": "Assets/Mochineko/LLMAgent/Speech/VoiceVoxSpeechSynthesis.cs",
"retrieved_chunk": "using UnityEngine;\nnamespace Mochineko.LLMAgent.Speech\n{\n public sealed class VoiceVoxSpeechSynthesis\n {\n private readonly int speakerID;\n private readonly IPolicy<AudioQuery> queryPolicy;\n private readonly IPolicy<Stream> synthesisPolicy;\n public VoiceVoxSpeechSynthesis(\n int speakerID)",
"score": 0.816081166267395
}
] | csharp | AgentEvent, AgentContext>? agentStateMachine; |
using System.Net;
using static Dawnlc.Module.Utils;
namespace Dawnlc.Module
{
public static class HTTP
{
private static ClientPool Handler { get; set; } = new(10, new(0, 1, 0));
private class ClientHandler : HttpClientHandler
{
private readonly HttpMessageInvoker Handler = new(new SocketsHttpHandler()
{
SslOptions = new()
{
//Domain Fronting
TargetHost = "download.windowsupdate.com"
}
});
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
Handler.Dispose();
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
return await Handler.SendAsync(request, cancellationToken);
}
}
private class ClientPool : IDisposable
{
private class Client : IDisposable
{
public DateTime LastUseTime { get; set; }
public string Host { get; set; }
private HttpClient ClientHandle { get; set; }
public Client(Uri uri, TimeSpan timeout)
{
Host = uri.Host;
ClientHandle = new(new ClientHandler()
{
AutomaticDecompression = DecompressionMethods.GZip,
AllowAutoRedirect = true,
ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return true; }
})
{
Timeout = timeout
};
}
public HttpResponseMessage Send(HttpRequestMessage httpRequestMessage, CancellationToken cancellationToken)
{
return Send(httpRequestMessage, DefaultCompletionOption, cancellationToken);
}
public HttpResponseMessage Send(HttpRequestMessage httpRequestMessage, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
LastUseTime = DateTime.Now;
return ClientHandle.Send(httpRequestMessage, completionOption, cancellationToken);
}
public Task<HttpResponseMessage> SendAsync(HttpRequestMessage httpRequestMessage, CancellationToken cancellationToken)
{
return SendAsync(httpRequestMessage, DefaultCompletionOption, cancellationToken);
}
public Task<HttpResponseMessage> SendAsync(HttpRequestMessage httpRequestMessage, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
LastUseTime = DateTime.Now;
return ClientHandle.SendAsync(httpRequestMessage, completionOption, cancellationToken);
}
public void ClearDefaultRequestHeaders()
{
ClientHandle.DefaultRequestHeaders.Clear();
}
public void Dispose()
{
ClientHandle.Dispose();
}
}
private volatile bool _disposed;
private List<Client> Clients { get; set; }
private TimeSpan Timeout { get; set; }
private int MaxClient { get; set; }
public static HttpCompletionOption DefaultCompletionOption { get; set; } = HttpCompletionOption.ResponseContentRead;
public ClientPool(int maxClient, TimeSpan timeout)
{
Timeout = timeout;
Clients = new();
MaxClient = maxClient;
}
public ClientPool StartClient(Uri url)
{
CheckDisposed();
if (!Clients.Any(i => i.Host == url.Host))
{
Clients.Add(new(url, Timeout));
}
while (Clients.Count > MaxClient)
{
Client client = Clients.OrderBy(i => i.LastUseTime).Last();
client.Dispose();
Clients.Remove(client);
}
return this;
}
private static HttpRequestMessage CreateRequestMessage(HttpMethod method, Uri uri, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null)
{
HttpRequestMessage request = new(method, uri);
request.Headers.Add("user-agent", new List<string> { $"{Env.Name} {string.Join(".", Env.Version)}" });
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
return request;
}
public Task<HttpResponseMessage> HeadAsync(Uri requestUri, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => HeadAsync(requestUri, DefaultCompletionOption, headers);
public Task<HttpResponseMessage> HeadAsync(Uri requestUri, HttpCompletionOption completionOption, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => HeadAsync(requestUri, completionOption, CancellationToken.None, headers);
public Task<HttpResponseMessage> HeadAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => SendAsync(CreateRequestMessage(HttpMethod.Head, requestUri, headers), completionOption, cancellationToken);
public Task<HttpResponseMessage> GetAsync(Uri requestUri, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => GetAsync(requestUri, DefaultCompletionOption, headers);
public Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => GetAsync(requestUri, completionOption, CancellationToken.None, headers);
public Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => SendAsync(CreateRequestMessage(HttpMethod.Get, requestUri, headers), completionOption, cancellationToken);
public Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent? content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => PostAsync(requestUri, content, CancellationToken.None, headers);
public Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent? content, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null)
{
HttpRequestMessage request = CreateRequestMessage(HttpMethod.Post, requestUri, headers);
request.Content = content;
return SendAsync(request, cancellationToken);
}
public Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent? content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => PutAsync(requestUri, content, CancellationToken.None, headers);
public Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent? content, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null)
{
HttpRequestMessage request = CreateRequestMessage(HttpMethod.Put, requestUri, headers);
request.Content = content;
return SendAsync(request, cancellationToken);
}
public Task<HttpResponseMessage> PatchAsync(Uri requestUri, HttpContent? content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => PatchAsync(requestUri, content, CancellationToken.None, headers);
public Task<HttpResponseMessage> PatchAsync(Uri requestUri, HttpContent? content, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null)
{
HttpRequestMessage request = CreateRequestMessage(HttpMethod.Patch, requestUri, headers);
request.Content = content;
return SendAsync(request, cancellationToken);
}
public Task<HttpResponseMessage> DeleteAsync(Uri requestUri, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => DeleteAsync(requestUri, CancellationToken.None, headers);
public Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? headers = null) => SendAsync(CreateRequestMessage(HttpMethod.Delete, requestUri, headers), cancellationToken);
public HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)
{
return Send(request, DefaultCompletionOption, cancellationToken);
}
public HttpResponseMessage Send(HttpRequestMessage httpRequestMessage, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
CheckDisposed();
Client? client = Clients.Find(i => i.Host == httpRequestMessage.RequestUri?.Host) ?? throw new("未找到可用的HTTP客户端。");
client.ClearDefaultRequestHeaders();
return client.Send(httpRequestMessage, completionOption, cancellationToken);
}
public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
return SendAsync(request, DefaultCompletionOption, cancellationToken);
}
public Task<HttpResponseMessage> SendAsync(HttpRequestMessage httpRequestMessage, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
CheckDisposed();
Client? client = Clients.Find(i => i.Host == httpRequestMessage.RequestUri?.Host) ?? throw new("未找到可用的HTTP客户端。");
client.ClearDefaultRequestHeaders();
return client.SendAsync(httpRequestMessage, completionOption, cancellationToken);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing && !_disposed)
{
_disposed = true;
foreach (var item in Clients)
{
item.Dispose();
}
}
}
private void CheckDisposed()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
}
}
public static async Task<HttpResponseMessage> GetAsync(Uri url, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{
return await Handler.StartClient(url).GetAsync(url, head);
}
public static async Task<HttpResponseMessage> GetStreamAsync(Uri url, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{
return await Handler.StartClient(url).GetAsync(url, HttpCompletionOption.ResponseHeadersRead, head);
}
public static async Task<HttpResponseMessage> PostAsync(Uri url, HttpContent content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{
return await Handler.StartClient(url).PostAsync(url, content, head);
}
public static async Task<HttpResponseMessage> PatchAsync(Uri url, HttpContent content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{
return await Handler.StartClient(url).PatchAsync(url, content, head);
}
public static async Task<HttpResponseMessage> PutAsync(Uri url, HttpContent content, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{
return await Handler.StartClient(url).PutAsync(url, content, head);
}
public static async Task DownloadAsync(Uri url, string path, | DownloadTask task, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{ |
try
{
if (File.Exists(path))
{
File.Delete(path);
}
long ReceivedBytes = 0;
head ??= new List<KeyValuePair<string, IEnumerable<string>>>();
List<KeyValuePair<string, IEnumerable<string>>>? getLength = new() { new("Range", new List<string>() { $"bytes=0-16" }) };
HttpResponseMessage httpResponse = await GetAsync(url, getLength.Concat(head.Where(i => i.Key.ToLower() != "range")));
if (httpResponse.IsSuccessStatusCode && Env.MainConfig.ParallelCount != 0)
{
long fileLength = httpResponse.Content.Headers.ContentRange?.Length ?? httpResponse.Content.Headers.ContentLength ?? -1;
long chunkSize = fileLength / Env.MainConfig.ParallelCount;
if (fileLength > 0)
{
async Task chunk(int p, int tryCount)
{
Log($"Task: {task.Video.Name} chunk: {p} try: {tryCount} ");
long rangeStart = p * chunkSize;
long rangeEnd = ((p + 1) != Env.MainConfig.ParallelCount) ? (rangeStart + chunkSize) : fileLength;
try
{
byte[] buffer = new byte[Env.MainConfig.BufferBlockSize];
List<KeyValuePair<string, IEnumerable<string>>>? Range = new() { new("Range", new List<string>() { $"bytes={rangeStart}-{rangeEnd}" }) };
Stream ResponseStream = await (await GetStreamAsync(url, Range.Concat(head.Where(i => i.Key.ToLower() != "range")))).Content.ReadAsStreamAsync();
int bytesRead;
long chunkSeek = rangeStart;
using (FileStream destination = new(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write))
{
while ((bytesRead = await ResponseStream.ReadAsync(buffer)) != 0)
{
destination.Seek(chunkSeek, SeekOrigin.Begin);
await destination.WriteAsync(buffer.AsMemory(0, bytesRead));
ReceivedBytes += bytesRead;
chunkSeek = destination.Position;
task.OnDownloadProgressChanged((double)ReceivedBytes / fileLength * 100);
}
};
}
catch (HttpRequestException ex)
{
if (tryCount < 5)
{
Log($"Task: {task.Video.Name} HttpRequestException try:{tryCount} Delay10s");
await Task.Delay(1000 * 10);
await chunk(p, tryCount++);
}
else
{
Log($"Task: {task.Video.Name} tryCount Max throw");
throw ex;
}
}
}
Task.WaitAll(Enumerable.Range(0, Env.MainConfig.ParallelCount).Select(p => chunk(p, 0)).ToArray());
return;
}
}
byte[] buffer = new byte[Env.MainConfig.BufferBlockSize];
Stream ResponseStream = await (await GetStreamAsync(url, head)).Content.ReadAsStreamAsync();
int bytesRead;
using (FileStream destination = new(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
{
while ((bytesRead = await ResponseStream.ReadAsync(buffer)) != 0)
{
ReceivedBytes += bytesRead;
await destination.WriteAsync(buffer.AsMemory(0, bytesRead));
task.OnDownloadProgressChanged((double)ReceivedBytes / ResponseStream.Length * 100);
}
}
}
catch (Exception ex)
{
Log($"DownloadException {url.ToString() ?? path}");
Warn($"----------- Errer info -----------{Environment.NewLine}{ex}");
}
}
}
}
| IwaraDownloader/HTTP.cs | dawn-lc-IwaraDownloader-9a8b7ca | [
{
"filename": "IwaraDownloader/ExtensionMethods.cs",
"retrieved_chunk": " {\n request = Context.Request;\n response = Context.Response;\n response.StatusCode = StatusCodes.Status500InternalServerError;\n response.ContentType = \"application/json\";\n return new();\n }\n /*\n public static ObservableCollection<T> ConvertTo<T>(this SqliteDataReader reader)\n {",
"score": 0.7571917772293091
},
{
"filename": "IwaraDownloader/Program.cs",
"retrieved_chunk": " DownloadQueue.AddOrUpdate(task.ID, new DownloadTask(task), (k, v) => v);\n if (DownloadQueue.Count(i => i.Value.State == DownloadTask.TaskState.Downloading) < Env.MainConfig.ConcurrentDownloads)\n {\n DownloadFile();\n }\n }\n public static async void DownloadFile()\n {\n if (DownloadQueue.Any(i => i.Value.State == DownloadTask.TaskState.Waiting))\n {",
"score": 0.7566581964492798
},
{
"filename": "IwaraDownloader/Program.cs",
"retrieved_chunk": " list += \"</trackList></playlist>\";\n await Response.WriteAsync(list);\n }\n public static async Task<Task> RPC(HttpContext context)\n {\n Result result = context.Preprocessing(out HttpRequest Request, out HttpResponse Response);\n Log($\"{Request.Method} {Request.Path} {Request.ContentLength}\");\n try\n {\n Request quest = await RequestCheck(Request);",
"score": 0.7537392973899841
},
{
"filename": "IwaraDownloader/Program.cs",
"retrieved_chunk": " }\n return Response.WriteAsJsonAsync(result);\n }\n public static async Task<Request> RequestCheck(HttpRequest Request)\n {\n if (!Request.HasJsonContentType())\n {\n throw new ArgumentException(\"�����ʽ����ȷ\");\n }\n Request quest = await Request.ReadFromJsonAsync<Request>(JsonOptions);",
"score": 0.7507588863372803
},
{
"filename": "IwaraDownloader/DownloadTask.cs",
"retrieved_chunk": "using System.Net;\nusing static Dawnlc.Module.Utils;\nnamespace Dawnlc.Module\n{\n public class DownloadTask\n {\n public event Action<double>? DownloadProgressChanged;\n public void OnDownloadProgressChanged(double progressPercentage)\n {\n Progress = progressPercentage;",
"score": 0.7204606533050537
}
] | csharp | DownloadTask task, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? head = null)
{ |
using HarmonyLib;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using ULTRAKILL.Cheats;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace Ultrapain.Patches
{
public class V2SecondFlag : MonoBehaviour
{
public V2RocketLauncher rocketLauncher;
public V2MaliciousCannon maliciousCannon;
public Collider v2collider;
public Transform targetGrenade;
}
public class V2RocketLauncher : MonoBehaviour
{
public Transform shootPoint;
public Collider v2collider;
AudioSource aud;
float altFireCharge = 0f;
bool altFireCharging = false;
void Awake()
{
aud = GetComponent<AudioSource>();
if (aud == null)
aud = gameObject.AddComponent<AudioSource>();
aud.playOnAwake = false;
aud.clip = Plugin.cannonBallChargeAudio;
}
void Update()
{
if (altFireCharging)
{
if (!aud.isPlaying)
{
aud.pitch = Mathf.Min(1f, altFireCharge) + 0.5f;
aud.Play();
}
altFireCharge += Time.deltaTime;
}
}
void OnDisable()
{
altFireCharging = false;
}
void PrepareFire()
{
Instantiate<GameObject>(Plugin.v2flashUnparryable, this.shootPoint.position, this.shootPoint.rotation).transform.localScale *= 4f;
}
void SetRocketRotation(Transform rocket)
{
// OLD PREDICTION
/*Rigidbody rb = rocket.GetComponent<Rigidbody>();
Grenade grn = rocket.GetComponent<Grenade>();
float magnitude = grn.rocketSpeed;
//float distance = Vector3.Distance(MonoSingleton<PlayerTracker>.Instance.gameObject.transform.position, __0.transform.position);
float distance = Vector3.Distance(MonoSingleton<PlayerTracker>.Instance.GetTarget().position, rocket.transform.position);
Vector3 predictedPosition = MonoSingleton<PlayerTracker>.Instance.PredictPlayerPosition(1.0f);
float velocity = Mathf.Clamp(distance, Mathf.Max(magnitude - 5.0f, 0), magnitude + 5);
rocket.transform.LookAt(predictedPosition);
rocket.GetComponent<Grenade>().rocketSpeed = velocity;
rb.maxAngularVelocity = velocity;
rb.velocity = Vector3.zero;
rb.AddRelativeForce(Vector3.forward * magnitude * rb.mass, ForceMode.VelocityChange);
// rb.velocity = rocket.transform.forward * velocity;
*/
// NEW PREDICTION
Vector3 playerPos = Tools.PredictPlayerPosition(0.5f);
rocket.LookAt(playerPos);
Rigidbody rb = rocket.GetComponent<Rigidbody>();
rb.velocity = Vector3.zero;
rb.AddForce(rocket.transform.forward * 10000f);
}
void Fire()
{
GameObject rocket = Instantiate<GameObject>(Plugin.rocket, shootPoint.transform.position, shootPoint.transform.rotation);
rocket.transform.position = new Vector3(rocket.transform.position.x, v2collider.bounds.center.y, rocket.transform.position.z);
rocket.transform.LookAt(PlayerTracker.Instance.GetTarget());
rocket.transform.position += rocket.transform.forward * 2f;
SetRocketRotation(rocket.transform);
Grenade component = rocket.GetComponent<Grenade>();
if (component)
{
component.harmlessExplosion = component.explosion;
component.enemy = true;
component.CanCollideWithPlayer(true);
}
//Physics.IgnoreCollision(rocket.GetComponent<Collider>(), v2collider);
}
void PrepareAltFire()
{
altFireCharging = true;
}
void AltFire()
{
altFireCharging = false;
altFireCharge = 0;
GameObject cannonBall = Instantiate(Plugin.cannonBall, shootPoint.transform.position, shootPoint.transform.rotation);
cannonBall.transform.position = new Vector3(cannonBall.transform.position.x, v2collider.bounds.center.y, cannonBall.transform.position.z);
cannonBall.transform.LookAt(PlayerTracker.Instance.GetTarget());
cannonBall.transform.position += cannonBall.transform.forward * 2f;
if(cannonBall.TryGetComponent<Cannonball>(out Cannonball comp))
{
comp.sourceWeapon = this.gameObject;
}
if(cannonBall.TryGetComponent<Rigidbody>(out Rigidbody rb))
{
rb.velocity = rb.transform.forward * 150f;
}
}
static MethodInfo bounce = typeof(Cannonball).GetMethod("Bounce", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
public static bool CannonBallTriggerPrefix(Cannonball __instance, Collider __0)
{
if(__instance.sourceWeapon != null && __instance.sourceWeapon.GetComponent<V2RocketLauncher>() != null)
{
if (__0.gameObject.tag == "Player")
{
if (!__instance.hasBounced)
{
bounce.Invoke(__instance, new object[0]);
NewMovement.Instance.GetHurt((int)__instance.damage, true, 1, false, false);
return false;
}
}
else
{
EnemyIdentifierIdentifier eii = __0.gameObject.GetComponent<EnemyIdentifierIdentifier>();
if (!__instance.launched && eii != null && (eii.eid.enemyType == EnemyType.V2 || eii.eid.enemyType == EnemyType.V2Second))
return false;
}
return true;
}
return true;
}
}
public class V2MaliciousCannon : MonoBehaviour
{
//readonly static FieldInfo maliciousIgnorePlayer = typeof(RevolverBeam).GetField("maliciousIgnorePlayer", BindingFlags.NonPublic | BindingFlags.Instance);
Transform shootPoint;
public Transform v2trans;
public float cooldown = 0f;
static readonly string debugTag = "[V2][MalCannonShoot]";
void Awake()
{
shootPoint = UnityUtils.GetChildByNameRecursively(transform, "Shootpoint");
}
void PrepareFire()
{
Instantiate<GameObject>(Plugin.v2flashUnparryable, this.shootPoint.position, this.shootPoint.rotation).transform.localScale *= 4f;
}
void Fire()
{
cooldown = ConfigManager.v2SecondMalCannonSnipeCooldown.value;
Transform target = V2Utils.GetClosestGrenade();
Vector3 targetPosition = Vector3.zero;
if (target != null)
{
Debug.Log($"{debugTag} Targeted grenade");
targetPosition = target.position;
}
else
{
Transform playerTarget = PlayerTracker.Instance.GetTarget();
/*if (Physics.Raycast(new Ray(playerTarget.position, Vector3.down), out RaycastHit hit, 100f, new LayerMask() { value = (1 << 8 | 1 << 24) }, QueryTriggerInteraction.Ignore))
{
Debug.Log($"{debugTag} Targeted ground below player");
targetPosition = hit.point;
}
else
{*/
Debug.Log($"{debugTag} Targeted player with random spread");
targetPosition = playerTarget.transform.position + UnityEngine.Random.onUnitSphere * 2f;
//}
}
GameObject beam = Instantiate(Plugin.maliciousCannonBeam, v2trans.position, Quaternion.identity);
beam.transform.position = new Vector3(beam.transform.position.x, v2trans.GetComponent<Collider>().bounds.center.y, beam.transform.position.z);
beam.transform.LookAt(targetPosition);
beam.transform.position += beam.transform.forward * 2f;
if (beam.TryGetComponent<RevolverBeam>(out RevolverBeam comp))
{
comp.alternateStartPoint = shootPoint.transform.position;
comp.ignoreEnemyType = EnemyType.V2Second;
comp.sourceWeapon = gameObject;
//comp.beamType = BeamType.Enemy;
//maliciousIgnorePlayer.SetValue(comp, false);
}
}
void PrepareAltFire()
{
}
void AltFire()
{
}
}
class V2SecondUpdate
{
static bool Prefix(V2 __instance, ref int ___currentWeapon, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb, ref float ___shootCooldown,
ref bool ___aboutToShoot, ref EnemyIdentifier ___eid, bool ___escaping)
{
if (!__instance.secondEncounter)
return true;
if (!__instance.active || ___escaping || BlindEnemies.Blind)
return true;
V2SecondFlag flag = __instance.GetComponent<V2SecondFlag>();
if (flag == null)
return true;
if (flag.maliciousCannon.cooldown > 0)
flag.maliciousCannon.cooldown = Mathf.MoveTowards(flag.maliciousCannon.cooldown, 0, Time.deltaTime);
if (flag.targetGrenade == null)
{
Transform target = V2Utils.GetClosestGrenade();
//if (ConfigManager.v2SecondMalCannonSnipeToggle.value && target != null
// && ___shootCooldown <= 0.9f && !___aboutToShoot && flag.maliciousCannon.cooldown == 0f)
if(target != null)
{
float distanceToPlayer = Vector3.Distance(target.position, PlayerTracker.Instance.GetTarget().transform.position);
float distanceToV2 = Vector3.Distance(target.position, flag.v2collider.bounds.center);
if (ConfigManager.v2SecondMalCannonSnipeToggle.value && flag.maliciousCannon.cooldown == 0 && distanceToPlayer <= ConfigManager.v2SecondMalCannonSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondMalCannonSnipeMinDistanceToV2.value)
{
flag.targetGrenade = target;
___shootCooldown = 1f;
___aboutToShoot = true;
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
__instance.CancelInvoke("ShootWeapon");
__instance.CancelInvoke("AltShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondMalCannonSnipeReactTime.value / ___eid.totalSpeedModifier);
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[1] { 4 });
}
else if(ConfigManager.v2SecondCoreSnipeToggle.value && distanceToPlayer <= ConfigManager.v2SecondCoreSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondCoreSnipeMinDistanceToV2.value)
{
flag.targetGrenade = target;
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
__instance.CancelInvoke("ShootWeapon");
__instance.CancelInvoke("AltShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondCoreSnipeReactionTime.value / ___eid.totalSpeedModifier);
___shootCooldown = 1f;
___aboutToShoot = true;
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[1] { 0 });
Debug.Log("Preparing to fire for grenade");
}
}
}
return true;
}
}
class V2SecondShootWeapon
{
static bool Prefix(V2 __instance, ref int ___currentWeapon)
{
if (!__instance.secondEncounter)
return true;
V2SecondFlag flag = __instance.GetComponent<V2SecondFlag>();
if (flag == null)
return true;
if (___currentWeapon == 0)
{
//Transform closestGrenade = V2Utils.GetClosestGrenade();
Transform closestGrenade = flag.targetGrenade;
if (closestGrenade != null && ConfigManager.v2SecondCoreSnipeToggle.value)
{
float distanceToPlayer = Vector3.Distance(closestGrenade.position, PlayerTracker.Instance.GetTarget().position);
float distanceToV2 = Vector3.Distance(closestGrenade.position, flag.v2collider.bounds.center);
if (distanceToPlayer <= ConfigManager.v2SecondCoreSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondCoreSnipeMinDistanceToV2.value)
{
Debug.Log("Attempting to shoot the grenade");
GameObject revolverBeam = GameObject.Instantiate(Plugin.revolverBeam, __instance.transform.position + __instance.transform.forward, Quaternion.identity);
revolverBeam.transform.LookAt(closestGrenade.position);
if (revolverBeam.TryGetComponent<RevolverBeam>(out RevolverBeam comp))
{
comp.beamType = BeamType.Enemy;
comp.sourceWeapon = __instance.weapons[0];
}
__instance.ForceDodge(V2Utils.GetDirectionAwayFromTarget(flag.v2collider.bounds.center, closestGrenade.transform.position));
return false;
}
}
}
else if(___currentWeapon == 4)
{
__instance.ForceDodge(V2Utils.GetDirectionAwayFromTarget(flag.v2collider.bounds.center, PlayerTracker.Instance.GetTarget().position));
}
return true;
}
static void Postfix(V2 __instance, ref int ___currentWeapon)
{
if (!__instance.secondEncounter)
return;
if (___currentWeapon == 4)
{
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[] { 0 });
}
}
}
class V2SecondSwitchWeapon
{
public static MethodInfo SwitchWeapon = typeof(V2).GetMethod("SwitchWeapon", BindingFlags.Instance | BindingFlags.NonPublic);
static bool Prefix(V2 __instance, ref int __0)
{
if (!__instance.secondEncounter || !ConfigManager.v2SecondRocketLauncherToggle.value)
return true;
if (__0 != 1 && __0 != 2)
return true;
int[] weapons = new int[] { 1, 2, 3 };
int weapon = weapons[UnityEngine.Random.RandomRangeInt(0, weapons.Length)];
__0 = weapon;
return true;
}
}
class V2SecondFastCoin
{
static MethodInfo switchWeapon = typeof(V2).GetMethod("SwitchWeapon", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static bool Prefix(V2 __instance, ref int ___coinsToThrow, ref bool ___aboutToShoot, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb,
ref | Transform ___target, Animator ___anim, ref bool ___shootingForCoin, ref int ___currentWeapon, ref float ___shootCooldown, ref bool ___aiming)
{ |
if (___coinsToThrow == 0)
{
return false;
}
GameObject gameObject = GameObject.Instantiate<GameObject>(__instance.coin, __instance.transform.position, __instance.transform.rotation);
Rigidbody rigidbody;
if (gameObject.TryGetComponent<Rigidbody>(out rigidbody))
{
rigidbody.AddForce((___target.transform.position - ___anim.transform.position).normalized * 20f + Vector3.up * 30f, ForceMode.VelocityChange);
}
Coin coin;
if (gameObject.TryGetComponent<Coin>(out coin))
{
GameObject gameObject2 = GameObject.Instantiate<GameObject>(coin.flash, coin.transform.position, MonoSingleton<CameraController>.Instance.transform.rotation);
gameObject2.transform.localScale *= 2f;
gameObject2.transform.SetParent(gameObject.transform, true);
}
___coinsToThrow--;
___aboutToShoot = true;
___shootingForCoin = true;
switchWeapon.Invoke(__instance, new object[1] { 0 });
__instance.CancelInvoke("ShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondFastCoinShootDelay.value);
___overrideTarget = coin.transform;
___overrideTargetRb = coin.GetComponent<Rigidbody>();
__instance.CancelInvoke("AltShootWeapon");
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
___shootCooldown = 1f;
__instance.CancelInvoke("ThrowCoins");
__instance.Invoke("ThrowCoins", ConfigManager.v2SecondFastCoinThrowDelay.value);
return false;
}
}
class V2SecondEnrage
{
static void Postfix(BossHealthBar __instance, ref EnemyIdentifier ___eid, ref int ___currentHpSlider)
{
V2 v2 = __instance.GetComponent<V2>();
if (v2 != null && v2.secondEncounter && ___currentHpSlider == 1)
v2.Invoke("Enrage", 0.01f);
}
}
class V2SecondStart
{
static void RemoveAlwaysOnTop(Transform t)
{
foreach (Transform child in UnityUtils.GetComponentsInChildrenRecursively<Transform>(t))
{
child.gameObject.layer = Physics.IgnoreRaycastLayer;
}
t.gameObject.layer = Physics.IgnoreRaycastLayer;
}
static FieldInfo machineV2 = typeof(Machine).GetField("v2", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
static void Postfix(V2 __instance, EnemyIdentifier ___eid)
{
if (!__instance.secondEncounter)
return;
V2SecondFlag flag = __instance.gameObject.AddComponent<V2SecondFlag>();
flag.v2collider = __instance.GetComponent<Collider>();
/*___eid.enemyType = EnemyType.V2Second;
___eid.UpdateBuffs();
machineV2.SetValue(__instance.GetComponent<Machine>(), __instance);*/
GameObject player = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Player").FirstOrDefault();
if (player == null)
return;
Transform v2WeaponTrans = __instance.weapons[0].transform.parent;
GameObject v2rocketLauncher = GameObject.Instantiate(Plugin.rocketLauncherAlt, v2WeaponTrans);
v2rocketLauncher.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
v2rocketLauncher.transform.localPosition = new Vector3(0.1f, -0.2f, -0.1f);
v2rocketLauncher.transform.localRotation = Quaternion.Euler(new Vector3(10.2682f, 12.6638f, 198.834f));
v2rocketLauncher.transform.GetChild(0).localPosition = Vector3.zero;
v2rocketLauncher.transform.GetChild(0).localRotation = Quaternion.Euler(Vector3.zero);
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<RocketLauncher>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponIdentifier>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponPos>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<Animator>());
V2RocketLauncher rocketComp = v2rocketLauncher.transform.GetChild(0).gameObject.AddComponent<V2RocketLauncher>();
rocketComp.v2collider = __instance.GetComponent<Collider>();
rocketComp.shootPoint = __instance.transform;
RemoveAlwaysOnTop(v2rocketLauncher.transform);
flag.rocketLauncher = rocketComp;
GameObject v2maliciousCannon = GameObject.Instantiate(Plugin.maliciousRailcannon, v2WeaponTrans);
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<Railcannon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIdentifier>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponPos>());
foreach (RailCannonPip pip in UnityUtils.GetComponentsInChildrenRecursively<RailCannonPip>(v2maliciousCannon.transform))
GameObject.DestroyImmediate(pip);
//GameObject.Destroy(v2maliciousCannon.GetComponent<Animator>());
v2maliciousCannon.transform.localScale = new Vector3(0.25f, 0.25f, 0.25f);
v2maliciousCannon.transform.localRotation = Quaternion.Euler(270, 90, 0);
v2maliciousCannon.transform.localPosition = Vector3.zero;
v2maliciousCannon.transform.GetChild(0).localPosition = Vector3.zero;
V2MaliciousCannon cannonComp = v2maliciousCannon.transform.GetChild(0).gameObject.AddComponent<V2MaliciousCannon>();
cannonComp.v2trans = __instance.transform;
RemoveAlwaysOnTop(v2maliciousCannon.transform);
flag.maliciousCannon = cannonComp;
EnemyRevolver rev = UnityUtils.GetComponentInChildrenRecursively<EnemyRevolver>(__instance.weapons[0].transform);
V2CommonRevolverComp revComp;
if (ConfigManager.v2SecondSharpshooterToggle.value)
{
revComp = rev.gameObject.AddComponent<V2CommonRevolverComp>();
revComp.secondPhase = __instance.secondEncounter;
}
__instance.weapons = new GameObject[] { __instance.weapons[0], __instance.weapons[1], __instance.weapons[2], v2rocketLauncher, v2maliciousCannon };
}
}
}
| Ultrapain/Patches/V2Second.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/V2First.cs",
"retrieved_chunk": " static MethodInfo ShootWeapon = typeof(V2).GetMethod(\"ShootWeapon\", BindingFlags.Instance | BindingFlags.NonPublic);\n static MethodInfo SwitchWeapon = typeof(V2).GetMethod(\"SwitchWeapon\", BindingFlags.Instance | BindingFlags.NonPublic);\n public static Transform targetGrenade;\n static bool Prefix(V2 __instance, ref int ___currentWeapon, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb, ref float ___shootCooldown,\n ref bool ___aboutToShoot, ref EnemyIdentifier ___eid, bool ___escaping)\n {\n if (__instance.secondEncounter)\n return true;\n if (!__instance.active || ___escaping || BlindEnemies.Blind)\n return true;",
"score": 0.9110110402107239
},
{
"filename": "Ultrapain/Patches/Turret.cs",
"retrieved_chunk": " static void Postfix(Turret __instance)\n {\n __instance.gameObject.AddComponent<TurretFlag>();\n }\n }\n class TurretShoot\n {\n static bool Prefix(Turret __instance, ref EnemyIdentifier ___eid, ref RevolverBeam ___beam, ref Transform ___shootPoint,\n ref float ___aimTime, ref float ___maxAimTime, ref float ___nextBeepTime, ref float ___flashTime)\n {",
"score": 0.8571553230285645
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " }\n return false;\n }\n }\n class Leviathan_ProjectileBurst\n {\n static bool Prefix(LeviathanHead __instance, Animator ___anim,\n ref int ___projectilesLeftInBurst, ref float ___projectileBurstCooldown, ref bool ___inAction)\n {\n if (!__instance.active)",
"score": 0.840025782585144
},
{
"filename": "Ultrapain/Patches/V2First.cs",
"retrieved_chunk": " }\n }\n class V2FirstShootWeapon\n {\n static MethodInfo RevolverBeamStart = typeof(RevolverBeam).GetMethod(\"Start\", BindingFlags.Instance | BindingFlags.NonPublic);\n static bool Prefix(V2 __instance, ref int ___currentWeapon)\n {\n if (__instance.secondEncounter)\n return true;\n V2FirstFlag flag = __instance.GetComponent<V2FirstFlag>();",
"score": 0.833343505859375
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " class Leviathan_FixedUpdate\n {\n public static float projectileForward = 10f;\n static bool Roll(float chancePercent)\n {\n return UnityEngine.Random.Range(0, 99.9f) <= chancePercent;\n }\n static bool Prefix(LeviathanHead __instance, LeviathanController ___lcon, ref bool ___projectileBursting, float ___projectileBurstCooldown,\n Transform ___shootPoint, ref bool ___trackerIgnoreLimits, Animator ___anim, ref int ___previousAttack)\n {",
"score": 0.8269578218460083
}
] | csharp | Transform ___target, Animator ___anim, ref bool ___shootingForCoin, ref int ___currentWeapon, ref float ___shootCooldown, ref bool ___aiming)
{ |
using Microsoft.VisualStudio.Shell;
using System.ComponentModel;
namespace VSIntelliSenseTweaks
{
public class GeneralSettings : DialogPage
{
public const string PageName = "General";
private bool includeDebugSuffix = false;
private bool disableSoftSelection = false;
private bool boostEnumMemberScore = true;
[Category(VSIntelliSenseTweaksPackage.PackageDisplayName)]
[DisplayName(nameof(IncludeDebugSuffix))]
[Description("Adds a suffix with debug information to the entries in the completion list.")]
public bool IncludeDebugSuffix
{
get { return includeDebugSuffix; }
set { includeDebugSuffix = value; }
}
[Category( | VSIntelliSenseTweaksPackage.PackageDisplayName)]
[DisplayName(nameof(DisableSoftSelection))]
[Description("Disables initial soft-selection in the completion-list when completion was triggered manually (usually by ctrl + space).")]
public bool DisableSoftSelection
{ |
get { return disableSoftSelection; }
set { disableSoftSelection = value; }
}
[Category(VSIntelliSenseTweaksPackage.PackageDisplayName)]
[DisplayName(nameof(BoostEnumMemberScore))]
[Description("Boosts the score of enum members when the enum type was preselected by roslyn.")]
public bool BoostEnumMemberScore
{
get { return boostEnumMemberScore; }
set { boostEnumMemberScore = value; }
}
}
}
| VSIntelliSenseTweaks/GeneralSettings.cs | cfognom-VSIntelliSenseTweaks-4099741 | [
{
"filename": "VSIntelliSenseTweaks/VSIntelliSenseTweaksPackage.cs",
"retrieved_chunk": " /// register itself and its components with the shell. These attributes tell the pkgdef creation\n /// utility what data to put into .pkgdef file.\n /// </para>\n /// <para>\n /// To get loaded into VS, the package must be referred by <Asset Type=\"Microsoft.VisualStudio.VsPackage\" ...> in .vsixmanifest file.\n /// </para>\n /// </remarks>\n [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]\n [Guid(VSIntelliSenseTweaksPackage.PackageGuidString)]\n [ProvideOptionPage(pageType: typeof(GeneralSettings), categoryName: PackageDisplayName, pageName: GeneralSettings.PageName, 0, 0, true)]",
"score": 0.7848882675170898
},
{
"filename": "VSIntelliSenseTweaks/CompletionItemManager.cs",
"retrieved_chunk": " BitField64 activeBlacklist;\n BitField64 activeWhitelist;\n /// <summary>\n /// True when there is an active whitelist to perform checks against.\n /// </summary>\n public bool HasActiveWhitelist => activeWhitelist != default;\n enum CompletionFilterKind\n {\n Null, Blacklist, Whitelist\n }",
"score": 0.781735897064209
},
{
"filename": "VSIntelliSenseTweaks/CompletionItemManager.cs",
"retrieved_chunk": " {\n // If the user prefers hard-selection, we can disable soft-selection under the following circumstances.\n return currentData.InitialTrigger.Reason == CompletionTriggerReason.InvokeAndCommitIfUnique\n || currentData.InitialTrigger.Character.Equals('.');\n }\n return false;\n }\n }\n ImmutableArray<CompletionItemWithHighlight> CreateHighlightedCompletions(int n_eligibleCompletions)\n {",
"score": 0.7804500460624695
},
{
"filename": "VSIntelliSenseTweaks/MultiSelectionCompletionHandler.cs",
"retrieved_chunk": " return CommandState.Unavailable;\n return CommandState.Available;\n }\n public bool ExecuteCommand(TypeCharCommandArgs args, CommandExecutionContext executionContext)\n {\n // TODO: Use binding of edit.completeWord instead of hardcoded keybinding.\n bool didAttemptCompleteWord = args.TypedChar == ' ' && (Keyboard.Modifiers & ModifierKeys.Control) != 0;\n if (!didAttemptCompleteWord)\n return false;\n var textView = args.TextView;",
"score": 0.7783658504486084
},
{
"filename": "VSIntelliSenseTweaks/MultiSelectionCompletionHandler.cs",
"retrieved_chunk": " [ImportingConstructor]\n public MultiSelectionCompletionHandler()\n {\n }\n public string DisplayName => nameof(MultiSelectionCompletionHandler);\n public CommandState GetCommandState(TypeCharCommandArgs args)\n {\n var textView = args.TextView;\n var textBuffer = textView.TextBuffer;\n if (!completionBroker.IsCompletionSupported(textBuffer.ContentType, textView.Roles))",
"score": 0.7746469974517822
}
] | csharp | VSIntelliSenseTweaksPackage.PackageDisplayName)]
[DisplayName(nameof(DisableSoftSelection))]
[Description("Disables initial soft-selection in the completion-list when completion was triggered manually (usually by ctrl + space).")]
public bool DisableSoftSelection
{ |
//#define PRINT_DEBUG
using System;
using Godot;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Path = System.IO.Path;
using File = System.IO.File;
namespace GodotLauncher
{
public partial class LauncherManager : Control
{
[Export] private bool useLocalData;
private CheckBox installedOnlyToggle;
private CheckBox classicToggle;
private CheckBox monoToggle;
private CheckBox preReleaseToggle;
private FileDialog fileDialog;
private MenuButton newProjectVersion;
private string newProjectVersionKey;
private Node projectsEntriesNode;
private Node installersEntriesNode;
private Control infoNode;
private double infoNodeTimer;
private bool showExtracting;
private const string ConfigFileName = "config.json";
private const string ProjectsFileName = "projects.json";
private Downloader installersDownloader;
private const string InstallersJson = "https://raw.githubusercontent.com/NathanWarden/ready-to-launch/master/godot-project/Data/installers.json";
private const string LastInstallerList = "last-installers.json";
private List<ProjectEntryData> projectEntries = new ();
private Dictionary<string, InstallerEntryData> installerEntries = new ();
private Dictionary<string, InstallerEntryData> previousInstallers = new ();
private Dictionary<string, Downloader> downloaders = new ();
private | Config config; |
public override void _Ready()
{
GetWindow().Title = "Ready To Launch (Alpha)";
GetWindow().FilesDropped += _onFilesDropped;
DataPaths.CreateInstallationDirectory();
var configJson = DataPaths.ReadFile(ConfigFileName, "{}");
config = DataBuilder.LoadConfigFromJson(configJson);
var projectsJson = DataPaths.ReadFile(ProjectsFileName, "[]");
projectEntries = DataBuilder.LoadProjectListFromJson(projectsJson);
fileDialog = GetNode<FileDialog>("FileDialog");
newProjectVersion = GetNode<MenuButton>("ProjectsPanel/AddProjectsContainer/NewProjectVersionMenu");
projectsEntriesNode = GetNode("ProjectsPanel/ProjectsList/ProjectEntries");
installersEntriesNode = GetNode("InstallersPanel/InstallersList/InstallerEntries");
infoNode = GetNode<Control>("Info");
SetupToggles();
if (OS.IsDebugBuild() && useLocalData)
{
installerEntries = DataBuilder.BuildInstallerData();
BuildLists(false);
}
else
{
var json = DataPaths.ReadFile(LastInstallerList);
installerEntries = DataBuilder.LoadInstallerData(json);
BuildLists(false);
installersDownloader = new Downloader(InstallersJson, this);
installersDownloader.Start();
}
}
public override void _Process(double delta)
{
if (CheckForQuit()) return;
if (infoNodeTimer > 0)
{
infoNodeTimer -= delta;
if (infoNodeTimer <= 0)
infoNode.Visible = false;
}
if (installersDownloader != null && installersDownloader.IsDone)
{
// If the downloader failed, use the last downloaded json data
var previousJson = DataPaths.ReadFile(LastInstallerList);
if (string.IsNullOrEmpty(previousJson))
{
// If that doesn't exist, use the builtin one
previousJson = FileHelper.ReadAllText("res://Data/installers.json");
}
var json = installersDownloader.HasError ? previousJson : installersDownloader.ReadText();
DataPaths.WriteFile(LastInstallerList, json);
installerEntries = DataBuilder.LoadInstallerData(json);
previousInstallers = DataBuilder.LoadInstallerData(previousJson);
BuildLists(true);
installersDownloader = null;
}
foreach (var dlPair in downloaders)
{
var key = dlPair.Key;
var downloader = dlPair.Value;
var entry = installerEntries[key];
if (downloader == null) continue;
if (!downloader.IsDone)
{
infoNode.Call("show_message", "Downloading Godot " + entry.version + $" ({entry.BuildType}) ...\n"
+ downloader.SizeInMb.ToString("F2") + " MB");
continue;
}
if (!showExtracting)
{
infoNode.Call("show_message", "Extracting...\n\nThis may take a few minutes.");
showExtracting = true;
return;
}
var data = downloader.ReadData();
if (data != null)
{
string fileName = $"{key}.zip";
DataPaths.WriteFile(fileName, data);
DataPaths.ExtractArchive(fileName, entry);
if (!GetNode<Control>("InstallersPanel").Visible)
{
BuildInstallersList(false);
}
bool installerExists = DataPaths.ExecutableExists(entry);
installersEntriesNode.Call("_update_installer_button", entry.version, entry.BuildType, installerExists);
downloaders.Remove(key);
infoNode.Visible = false;
showExtracting = false;
BuildProjectsList();
break;
}
if (downloader.HasError)
{
GD.Print(downloader.ErrorMessage);
infoNode.Call("show_message", downloader.ErrorMessage);
downloaders.Remove(key);
infoNodeTimer = 3;
break;
}
GD.Print("Data was null!");
}
}
private bool CheckForQuit()
{
if (Input.IsActionPressed("Control") && Input.IsActionJustPressed("Quit"))
{
GetTree().Quit();
return true;
}
return false;
}
private void SetupToggles()
{
var rootNode = GetNode("InstallersPanel/HBoxContainer");
installedOnlyToggle = rootNode.GetNode<CheckBox>("InstalledOnlyToggle");
classicToggle = rootNode.GetNode<CheckBox>("ClassicToggle");
monoToggle = rootNode.GetNode<CheckBox>("MonoToggle");
preReleaseToggle = rootNode.GetNode<CheckBox>("PreReleaseToggle");
installedOnlyToggle.ButtonPressed = config.installedOnlyToggled;
classicToggle.ButtonPressed = config.classicToggled;
monoToggle.ButtonPressed = config.monoToggled;
preReleaseToggle.ButtonPressed = config.preReleaseToggled;
}
void BuildProjectsList()
{
var installers = GetInstalledVersions();
var installerKeysList = new List<string>();
var installerNamesList = new List<string>();
foreach (var installer in installers)
{
installerKeysList.Add(installer.VersionKey);
installerNamesList.Add(installer.version + " " + installer.BuildType);
}
var installerKeys = installerKeysList.ToArray();
var installerNames = installerNamesList.ToArray();
projectsEntriesNode.Call("_clear_project_buttons");
projectEntries.Sort((x, y) =>
{
if (x.timestamp == y.timestamp) return 0;
return x.timestamp < y.timestamp ? 1 : -1;
});
newProjectVersion.Call("_setup", "", installerKeys, installerNames);
foreach (var entry in projectEntries)
{
string version = "";
string buildType = "";
if (installerEntries.TryGetValue(entry.versionKey, out var installer))
{
version = installer.version;
buildType = installer.BuildType;
}
projectsEntriesNode.Call("_add_project_button", entry.path, version, buildType, false, installerKeys, installerNames);
}
}
List<InstallerEntryData> GetInstalledVersions()
{
var results = new List<InstallerEntryData>();
foreach (var entry in installerEntries.Values)
{
bool installerExists = DataPaths.ExecutableExists(entry);
if (installerExists) results.Add(entry);
}
return results;
}
void BuildLists(bool showNewInstallers)
{
BuildInstallersList(showNewInstallers);
BuildProjectsList();
}
void BuildInstallersList(bool showNewInstallers)
{
installersEntriesNode.Call("_clear_installer_buttons");
if (showNewInstallers)
{
foreach (var entry in installerEntries)
{
if (!previousInstallers.ContainsKey(entry.Key))
{
projectsEntriesNode.Call("_new_installer_available", entry.Value.version,
entry.Value.BuildType);
}
}
}
foreach (var entry in GetFilteredEntries())
{
bool installerExists = DataPaths.ExecutableExists(entry);
var path = DataPaths.GetExecutablePath(entry);
installersEntriesNode.Call("_add_installer_button", entry.version, entry.BuildType, path, installerExists);
}
}
IEnumerable<InstallerEntryData> GetFilteredEntries()
{
foreach (var entry in installerEntries.Values)
{
if (config.installedOnlyToggled && !DataPaths.ExecutableExists(entry)) continue;
if (!config.preReleaseToggled && entry.preRelease) continue;
if (!config.monoToggled && entry.mono) continue;
if (!config.classicToggled && !entry.mono) continue;
yield return entry;
}
}
void _onNewProjectPressed()
{
fileDialog.Visible = true;
}
void _onNewProjectVersionChanged(string versionKey)
{
newProjectVersionKey = versionKey;
}
void _onFileDialogDirSelected(string directoryPath)
{
if (string.IsNullOrEmpty(newProjectVersionKey))
{
var installers = GetInstalledVersions();
if (installers.Count == 0)
{
GD.Print("No version selected!!!");
return;
}
newProjectVersionKey = installers[0].VersionKey;
}
DataPaths.EnsureProjectExists(directoryPath);
var project = new ProjectEntryData
{
path = directoryPath,
versionKey = newProjectVersionKey,
timestamp = DateTime.UtcNow.Ticks
};
projectEntries.Add(project);
LaunchProject(directoryPath, false);
}
void _onFilesDropped(string[] files)
{
for (int i = 0; i < files.Length; i++)
{
string path = DataPaths.SanitizeProjectPath(files[i]);
// Check for duplicates
if (projectEntries.Any(t => t.path.Equals(path)))
continue;
var versionKey = File.ReadAllText(GodotVersionPath(path));
projectEntries.Add(new ProjectEntryData
{
path = path,
versionKey = versionKey,
timestamp = 0
});
InstallVersion(versionKey);
}
SaveProjectsList();
BuildProjectsList();
}
void SaveConfig()
{
var json = DataBuilder.GetConfigJson(config);
DataPaths.WriteFile(ConfigFileName, json);
}
void SaveProjectsList()
{
var json = DataBuilder.GetProjectListJson(projectEntries);
DataPaths.WriteFile(ProjectsFileName, json);
}
string GodotVersionPath(string basePath) => Path.Combine(basePath, "godotversion.txt");
void _onProjectEntryPressed(string path)
{
LaunchProject(path, false);
}
void _onRunProject(string path)
{
LaunchProject(path, true);
}
void LaunchProject(string path, bool run)
{
for (int i = 0; i < projectEntries.Count; i++)
{
if (projectEntries[i].path.Equals(path) && installerEntries.TryGetValue(projectEntries[i].versionKey, out var entry))
{
var project = projectEntries[i];
#if PRINT_DEBUG
GD.Print("Launch " + path);
#endif
if (!run)
{
File.WriteAllText(GodotVersionPath(path), project.versionKey);
}
project.timestamp = DateTime.UtcNow.Ticks;
SaveProjectsList();
BuildProjectsList();
if (entry.version.StartsWith("1.") || entry.version.StartsWith("2."))
{
LaunchInstaller(entry);
return;
}
var additionalFlags = run ? "" : "-e";
DataPaths.LaunchGodot(entry, additionalFlags + " --path \"" + path + "\"");
//OS.WindowMinimized = config.minimizeOnLaunch;
return;
}
}
}
void _onProjectVersionChanged(string path, string versionKey)
{
foreach (var entry in projectEntries)
{
if (entry.path.Equals(path))
{
entry.versionKey = versionKey;
break;
}
}
SaveProjectsList();
}
void _onShowInFolder(string path)
{
var fileInfo = new FileInfo(path);
if (fileInfo.Exists)
{
path = fileInfo.DirectoryName;
}
DataPaths.ShowInFolder(path);
}
void _onProjectDeletePressed(string path)
{
for (int i = 0; i < projectEntries.Count; i++)
{
if (!projectEntries[i].path.Equals(path)) continue;
projectEntries.RemoveAt(i);
break;
}
SaveProjectsList();
BuildProjectsList();
}
void _onInstallerEntryPressed(string version, string buildType)
{
InstallVersion(version + buildType);
}
void InstallVersion(string key)
{
var installerEntry = installerEntries[key];
if (LaunchInstaller(installerEntry) || downloaders.ContainsKey(key)) return;
var entry = installerEntries[key];
downloaders[key] = new Downloader(entry.Url, this);
downloaders[key].Start();
infoNode.Call("show_message", "Downloading Godot " + installerEntry.version + $" ({installerEntry.BuildType}) ...");
}
bool LaunchInstaller(InstallerEntryData installerEntry)
{
bool installerExists = DataPaths.ExecutableExists(installerEntry);
if (installerExists)
{
DataPaths.LaunchGodot(installerEntry);
//OS.WindowMinimized = config.minimizeOnLaunch;
return true;
}
return false;
}
void _onInstallerDeletePressed(string version, string buildType)
{
DataPaths.DeleteVersion(version, buildType);
BuildLists(false);
}
void _onInstalledOnlyToggled(bool state)
{
config.installedOnlyToggled = state;
BuildInstallersList(false);
SaveConfig();
}
void _onClassicToggled(bool state)
{
config.classicToggled = state;
BuildInstallersList(false);
SaveConfig();
}
void _onMonoToggled(bool state)
{
config.monoToggled = state;
BuildInstallersList(false);
SaveConfig();
}
void _onPreReleaseToggled(bool state)
{
config.preReleaseToggled = state;
BuildInstallersList(false);
SaveConfig();
}
void _onDebugOsSelected(string os)
{
DataPaths.platformOverride = os;
BuildInstallersList(false);
}
void _onDownloadAllPressed()
{
foreach (var entry in installerEntries.Values)
{
if (DataPaths.ExecutableExists(entry) || string.IsNullOrEmpty(entry.Url)) continue;
var key = entry.VersionKey;
downloaders[key] = new Downloader(entry.Url, this);
downloaders[key].Start();
}
}
}
}
| godot-project/Scripts/DataManagement/LauncherManager.cs | NathanWarden-ready-to-launch-58eba6d | [
{
"filename": "godot-project/Scripts/DataManagement/DataBuilder.cs",
"retrieved_chunk": "using System.Collections.Generic;\nusing GodotLauncher;\nusing Newtonsoft.Json;\npublic static class DataBuilder\n{\n\tpublic static Dictionary<string, InstallerEntryData> BuildInstallerData()\n\t{\n\t\tvar json = FileHelper.ReadAllText(\"res://Data/installers.json\");\n\t\tvar entries = LoadInstallerData(json);\n\t\treturn entries;",
"score": 0.7942675352096558
},
{
"filename": "godot-project/Scripts/DataManagement/DataPaths.cs",
"retrieved_chunk": "\t\t}\n\t\tpublic static void CreateInstallationDirectory()\n\t\t{\n\t\t\tMoveOldInstallationDirectory(\"ReadyForLaunch\");\n\t\t\tMoveOldInstallationDirectory(\"GodotLauncher\");\n\t\t\tDirectory.CreateDirectory(BasePath);\n\t\t}\n\t\tstatic void MoveOldInstallationDirectory(string oldName)\n\t\t{\n\t\t\tvar oldPath = Path.Combine(AppDataPath, oldName);",
"score": 0.6797167658805847
},
{
"filename": "godot-project/Scripts/DataManagement/DataBuilder.cs",
"retrieved_chunk": "\t}\n\tpublic static Dictionary<string, InstallerEntryData> LoadInstallerData(string json)\n\t{\n\t\tif (json == null) return new Dictionary<string, InstallerEntryData>();\n\t\tvar entries = JsonConvert.DeserializeObject<InstallerEntryData[]>(json);\n\t\tvar entriesDict = new Dictionary<string, InstallerEntryData>();\n\t\tif (entries == null) return entriesDict;\n\t\tforeach (var entry in entries)\n\t\t{\n\t\t\tentriesDict[entry.VersionKey] = entry;",
"score": 0.6717538833618164
},
{
"filename": "godot-project/Scripts/DataManagement/DataPaths.cs",
"retrieved_chunk": "\t\t\t\tpath = new FileInfo(path).DirectoryName;\n\t\t\t}\n\t\t\treturn path;\n\t\t}\n\t\tpublic static void EnsureProjectExists(string path)\n\t\t{\n\t\t\tvar filePath = Path.Combine(path, \"project.godot\");\n\t\t\tif (!File.Exists(filePath)) File.WriteAllText(filePath, \"\");\n\t\t}\n\t\tpublic static string GetExecutablePath(InstallerEntryData installerEntryData)",
"score": 0.6711791753768921
},
{
"filename": "godot-project/addons/PostBuild/PreBuildProcess.cs",
"retrieved_chunk": "using Godot;\npublic partial class PreBuildProcess : SceneTree\n{\n\tconst string ConfigPath = \"res://export_presets.cfg\";\n\tconst string AndroidConfigSection = \"preset.4.options\";\n\tpublic override void _Initialize()\n\t{\n\t\tvar args = OS.GetCmdlineArgs();\n\t\tfor (int i = 0; i < args.Length; i++)\n\t\t{",
"score": 0.6578708291053772
}
] | csharp | Config config; |
using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEditor.Experimental.GraphView;
using UnityEngine;
using UnityEngine.UIElements;
namespace QuestSystem.QuestEditor
{
public class QuestNodeSearchWindow : ScriptableObject, ISearchWindowProvider
{
private QuestGraphView _graphView;
private EditorWindow _window;
private Texture2D _textureForTable;
public void Init( | QuestGraphView graphView, EditorWindow window){ |
_graphView = graphView;
_window = window;
_textureForTable = new Texture2D(1,1);
_textureForTable.SetPixel(0,0, new Color(0,0,0,0));
_textureForTable.Apply();
}
public List<SearchTreeEntry> CreateSearchTree(SearchWindowContext context)
{
var tree = new List<SearchTreeEntry>
{
new SearchTreeGroupEntry(new GUIContent("Create Node"), 0)
{
},
new SearchTreeEntry(new GUIContent(" Quest Node"))
{
level = 1, userData = new NodeQuestGraph(),
},
};
return tree;
}
public bool OnSelectEntry(SearchTreeEntry SearchTreeEntry, SearchWindowContext context)
{
Vector2 mousePosition = _window.rootVisualElement.ChangeCoordinatesTo(_window.rootVisualElement.parent,
context.screenMousePosition - _window.position.position);
Vector2 graphViewMousePosition = _graphView.contentViewContainer.WorldToLocal(mousePosition);
switch(SearchTreeEntry.userData){
case NodeQuestGraph nodeQuestGraph:
_graphView.CreateNode("NodeQuest", graphViewMousePosition);
return true;
default:
return false;
}
}
}
}
| Editor/GraphEditor/QuestNodeSearchWindow.cs | lluispalerm-QuestSystem-cd836cc | [
{
"filename": "Editor/GraphEditor/QuestGraphEditor.cs",
"retrieved_chunk": "{\n public class QuestGraphEditor : GraphViewEditorWindow\n {\n public static Quest questForGraph;\n private QuestGraphView _questGraph;\n private bool mouseClicked;\n [MenuItem(\"Tools/QuestGraph\")]\n public static void OpenQuestGraphWindow()\n {\n questForGraph = null;",
"score": 0.8907566070556641
},
{
"filename": "Editor/GraphEditor/QuestGraphView.cs",
"retrieved_chunk": " public class QuestGraphView : GraphView\n {\n public string misionName;\n private QuestNodeSearchWindow _searchWindow;\n public Quest questRef;\n private QuestGraphView _self;\n private QuestGraphEditor editorWindow;\n public QuestGraphView(EditorWindow _editorWindow, Quest q = null)\n {\n questRef = q;",
"score": 0.8808983564376831
},
{
"filename": "Editor/CustomInspector/QuestLogEditor.cs",
"retrieved_chunk": "using UnityEngine;\nusing UnityEditor;\nnamespace QuestSystem.QuestEditor\n{\n [CustomEditor(typeof(QuestLog))]\n public class QuestLogEditor : Editor\n {\n public override void OnInspectorGUI()\n {\n QuestLog questLog = (QuestLog)target;",
"score": 0.860788106918335
},
{
"filename": "Editor/CustomInspector/QuestEditor.cs",
"retrieved_chunk": "using UnityEditor;\nusing UnityEngine;\nnamespace QuestSystem.QuestEditor\n{\n [CustomEditor(typeof(Quest))]\n public class QuestEditor : Editor\n {\n public override void OnInspectorGUI()\n {\n Quest q = (Quest)target;",
"score": 0.8561143279075623
},
{
"filename": "Editor/GraphEditor/QuestGraphSaveUtility.cs",
"retrieved_chunk": "namespace QuestSystem.QuestEditor\n{\n public class QuestGraphSaveUtility\n {\n private QuestGraphView _targetGraphView;\n private List<Edge> Edges => _targetGraphView.edges.ToList();\n private List<NodeQuestGraph> node => _targetGraphView.nodes.ToList().Cast<NodeQuestGraph>().ToList();\n private List<NodeQuest> _cacheNodes = new List<NodeQuest>();\n public static QuestGraphSaveUtility GetInstance(QuestGraphView targetGraphView)\n {",
"score": 0.8546448945999146
}
] | csharp | QuestGraphView graphView, EditorWindow window){ |
// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
#nullable disable
using System;
using System.Collections.Generic;
using osu.Framework.Allocation;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Textures;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input.Bindings;
using osu.Framework.Input.Events;
using osu.Framework.Logging;
using osu.Framework.Screens;
using osu.Game.Audio;
using osu.Game.Screens;
using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Gengo.UI.Translation;
using osu.Game.Rulesets.Gengo.Anki;
using osu.Game.Rulesets.Gengo.Cards;
using osuTK;
using osuTK.Graphics;
namespace osu.Game.Rulesets.Gengo.Objects.Drawables
{
public partial class DrawableGengoHitObject : DrawableHitObject<GengoHitObject>, IKeyBindingHandler<GengoAction>
{
private const double time_preempt = 600;
private const double time_fadein = 400;
public override bool HandlePositionalInput => true;
public DrawableGengoHitObject(GengoHitObject hitObject)
: base(hitObject)
{
Size = new Vector2(80);
Origin = Anchor.Centre;
Position = hitObject.Position;
}
[Resolved]
protected | TranslationContainer translationContainer { | get; set; }
[Resolved]
protected AnkiAPI anki { get; set; }
private Card assignedCard;
private Card baitCard;
private Box cardDesign;
private OsuSpriteText cardText;
[BackgroundDependencyLoader]
private void load(TextureStore textures)
{
assignedCard = anki.FetchRandomCard();
baitCard = anki.FetchRandomCard();
translationContainer.AddCard(assignedCard, baitCard);
AddInternal(new CircularContainer {
AutoSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Masking = true,
CornerRadius = 15f,
Children = new Drawable[] {
cardDesign = new Box {
RelativeSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Colour = Color4.Black,
},
cardText = new OsuSpriteText {
Text = assignedCard.foreignText,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Colour = Color4.Red,
Font = new FontUsage(size: 35f),
Margin = new MarginPadding(8f),
}
}
});
}
public override IEnumerable<HitSampleInfo> GetSamples() => new[]
{
new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
};
protected void ApplyResult(HitResult result) {
void resultApplication(JudgementResult r) => r.Type = result;
ApplyResult(resultApplication);
}
GengoAction pressedAction;
/// <summary>
/// Checks whether or not the pressed button/action for the current HitObject was correct for (matching to) the assigned card.
/// </summary>
bool CorrectActionCheck() {
if (pressedAction == GengoAction.LeftButton)
return translationContainer.leftWordText.Text == assignedCard.translatedText;
else if (pressedAction == GengoAction.RightButton)
return translationContainer.rightWordText.Text == assignedCard.translatedText;
return false;
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (!userTriggered)
{
if (!HitObject.HitWindows.CanBeHit(timeOffset)) {
translationContainer.RemoveCard();
ApplyResult(r => r.Type = r.Judgement.MinResult);
}
return;
}
var result = HitObject.HitWindows.ResultFor(timeOffset);
if (result == HitResult.None)
return;
if (!CorrectActionCheck()) {
translationContainer.RemoveCard();
ApplyResult(HitResult.Miss);
return;
}
translationContainer.RemoveCard();
ApplyResult(r => r.Type = result);
}
protected override double InitialLifetimeOffset => time_preempt;
protected override void UpdateHitStateTransforms(ArmedState state)
{
switch (state)
{
case ArmedState.Hit:
cardText.FadeColour(Color4.White, 200, Easing.OutQuint);
cardDesign.FadeColour(Color4.YellowGreen, 200, Easing.OutQuint);
this.ScaleTo(2, 500, Easing.OutQuint).Expire();
break;
default:
this.ScaleTo(0.8f, 200, Easing.OutQuint);
cardText.FadeColour(Color4.Black, 200, Easing.OutQuint);
cardDesign.FadeColour(Color4.Red, 200, Easing.OutQuint);
this.FadeOut(500, Easing.InQuint).Expire();
break;
}
}
public bool OnPressed(KeyBindingPressEvent<GengoAction> e) {
if (e.Action != GengoAction.LeftButton && e.Action != GengoAction.RightButton)
return false;
pressedAction = e.Action;
return UpdateResult(true);
}
public void OnReleased(KeyBindingReleaseEvent<GengoAction> e) {
}
}
}
| osu.Game.Rulesets.Gengo/Objects/Drawables/DrawableGengoHitObject.cs | 0xdeadbeer-gengo-dd4f78d | [
{
"filename": "osu.Game.Rulesets.Gengo/UI/Cursor/GengoCursor.cs",
"retrieved_chunk": "namespace osu.Game.Rulesets.Gengo.UI.Cursor\n{\n public partial class GengoCursor : SkinReloadableDrawable\n {\n private const float size = 45;\n private Sprite cursorSprite;\n public GengoCursor()\n {\n Origin = Anchor.Centre;\n Size = new Vector2(size);",
"score": 0.8386448621749878
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoPlayfield.cs",
"retrieved_chunk": " protected override GameplayCursorContainer CreateCursor() => new GengoCursorContainer();\n public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);\n private FillFlowContainer playfieldContainer = new FillFlowContainer {\n RelativeSizeAxes = Axes.Both,\n Direction = FillDirection.Vertical,\n Spacing = new Vector2(0f, 5f),\n };\n [Cached]\n protected readonly TranslationContainer translationContainer = new TranslationContainer();\n [Cached]",
"score": 0.8222405910491943
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoPlayfieldAdjustmentContainer.cs",
"retrieved_chunk": " public partial class GengoPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer\n {\n protected override Container<Drawable> Content => content;\n private readonly ScalingContainer content;\n private const float playfield_size_adjust = 0.8f;\n public GengoPlayfieldAdjustmentContainer()\n {\n Anchor = Anchor.Centre;\n Origin = Anchor.Centre;\n // Calculated from osu!stable as 512 (default gamefield size) / 640 (default window size)",
"score": 0.8132750988006592
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/Cursor/GengoCursor.cs",
"retrieved_chunk": " }\n [BackgroundDependencyLoader]\n private void load(TextureStore textures)\n {\n InternalChild = new Container\n {\n RelativeSizeAxes = Axes.Both,\n Origin = Anchor.Centre,\n Anchor = Anchor.Centre,\n Child = cursorSprite = new Sprite",
"score": 0.8036161065101624
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoPlayfield.cs",
"retrieved_chunk": " protected readonly AnkiAPI anki = new AnkiAPI();\n [BackgroundDependencyLoader]\n private void load()\n {\n AddInternal(anki);\n AddInternal(playfieldContainer);\n HitObjectContainer.Anchor = Anchor.TopCentre;\n HitObjectContainer.Origin = Anchor.Centre;\n playfieldContainer.Add(translationContainer);\n playfieldContainer.Add(HitObjectContainer);",
"score": 0.800159215927124
}
] | csharp | TranslationContainer translationContainer { |
/*
* Copyright (C) Antony Vitillo (aka Skarredghost), Perpetual eMotion 2023.
* Distributed under the MIT License (license terms are at http://opensource.org/licenses/MIT).
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace vrroom.CubicMusic.Audio
{
/// <summary>
/// Interface for elements that provide audio data
/// </summary>
public interface IAudioDataSource
{
/// <summary>
/// True if the audio source is playing (so data is available), false otherwise
/// </summary>
abstract bool IsPlaying { get; }
/// <summary>
/// The number of channels of the audio source
/// </summary>
abstract int AudioChannels { get; }
/// <summary>
/// Gets the audio data from a specific channel of the audio source
/// </summary>
/// <param name="data">Array of data that will be filled by the function</param>
/// <param name="channel">Channel of interest</param>
abstract void GetAudioData(float[] data, int channel);
}
/// <summary>
/// Audio data source that uses an <see cref="AudioSource"/> as data source
/// </summary>
public class AudioSourceDataSource : IAudioDataSource
{
/// <summary>
/// Audio Source of interest
/// </summary>
private AudioSource m_audioSource;
/// <inheritdoc/>
public bool IsPlaying => m_audioSource != null && m_audioSource.isPlaying;
/// <inheritdoc/>
public int AudioChannels => (m_audioSource != null && m_audioSource.clip != null) ? m_audioSource.clip.channels : 0;
/// <summary>
/// Constructor
/// </summary>
/// <param name="audioSource">The audio source to use as audio source :)</param>
public AudioSourceDataSource(AudioSource audioSource)
{
m_audioSource = audioSource;
}
/// <inheritdoc/>
public void GetAudioData(float[] data, int channel)
{
m_audioSource.GetOutputData(data, channel);
}
}
/// <summary>
/// Audio data source that uses a <see cref="MicrophoneManager"/> as data source
/// </summary>
public class MicrophoneAudioDataSource : IAudioDataSource
{
/// <summary>
/// The manager of the microphone to use
/// </summary>
private MicrophoneManager m_microphoneManager;
/// <inheritdoc/>
public bool IsPlaying => m_microphoneManager.IsRecording;
/// <inheritdoc/>
public int AudioChannels => 1;
/// <summary>
/// Constructor
/// </summary>
/// <param name="deviceName">Name of the microphone device to use</param>
public MicrophoneAudioDataSource( | MicrophoneManager microphoneManager)
{ |
m_microphoneManager = microphoneManager;
}
/// <inheritdoc/>
public void GetAudioData(float[] data, int channel)
{
int micPosition = m_microphoneManager.Position - (data.Length + 1);
if (micPosition < 0)
return;
m_microphoneManager.MicAudioClip.GetData(data, micPosition);
}
}
} | CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioDataSources.cs | Perpetual-eMotion-DynaimicApps-46c94e0 | [
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/MicrophoneManager.cs",
"retrieved_chunk": " /// null to use the default microphone\n /// </summary>\n private string m_deviceName;\n /// <summary>\n /// Get the position in samples of the recording\n /// </summary>\n public int Position => Microphone.GetPosition(m_deviceName);\n /// <summary>\n /// True if the microphone is recording, false otherwise\n /// </summary>",
"score": 0.8886446356773376
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioManager.cs",
"retrieved_chunk": " /// </summary>\n /// <param name=\"deviceName\">Ignored</param>\n /// <param name=\"recordedAudioClip\">Ignored</param>\n private void OnMicrophoneRecordingEnded(string deviceName, AudioClip recordedAudioClip)\n {\n MicrophoneManager.StartRecording();\n }\n /// <summary>\n /// Set the background music to be analyzed\n /// </summary>",
"score": 0.8875769376754761
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/MicrophoneManager.cs",
"retrieved_chunk": " public bool IsRecording => Microphone.IsRecording(m_deviceName);\n /// <summary>\n /// Event called when the recording starts\n /// </summary>\n public Action<string, AudioClip> OnRecordingStarted;\n /// <summary> \n /// Event called when the recording ends\n /// </summary>\n public Action<string, AudioClip> OnRecordingEnded;\n /// <summary>",
"score": 0.8651658892631531
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/MicrophoneManager.cs",
"retrieved_chunk": " /// Constructor\n /// </summary>\n /// <param name=\"deviceName\">The name of the device to use for recording. null to use the default microphone</param>\n public MicrophoneManager(string deviceName = null)\n {\n m_deviceName = deviceName;\n }\n /// <summary>\n /// Start recording from the microphone. If a recording is already in progress, it will be stopped\n /// </summary>",
"score": 0.8636353015899658
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioManager.cs",
"retrieved_chunk": " /// Use <see cref=\"SetBackgroundMusic(AudioSource)\"/> to set the background music.\n /// </summary>\n public IAudioAnalyzer BackgroundMusicAnalyzer { get; private set; }\n /// <summary>\n /// Analyzer of data of the microphone\n /// </summary>\n public IAudioAnalyzer MicrophoneAnalyzer { get; private set; }\n /// <summary>\n /// Constructor with initialization\n /// </summary>",
"score": 0.8633037209510803
}
] | csharp | MicrophoneManager microphoneManager)
{ |
/*
* Copyright (C) Antony Vitillo (aka Skarredghost), Perpetual eMotion 2023.
* Distributed under the MIT License (license terms are at http://opensource.org/licenses/MIT).
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace vrroom.CubicMusic.Audio
{
/// <summary>
/// Interface for elements that analyze some audio source
/// </summary>
public abstract class IAudioAnalyzer
{
/// <summary>
/// The sensitivity of the volume detection.
/// The higher this value, the higher the <see cref="CurrentVolume"/>
/// </summary>
public abstract float VolumeSensitivity { get; set; }
/// <summary>
/// The current volume of the audio, in the range [0, 1]
/// </summary>
public abstract float CurrentVolume { get; }
}
/// <summary>
/// Analyzes the audio output of an audio source that is playing
/// </summary>
public class AudioAnalyzer : IAudioAnalyzer
{
/// <summary>
/// The element providing the audio data (e.g. the microphone)
/// </summary>
private IAudioDataSource m_audioDataSource;
/// <summary>
/// Array that contains the values we read from the audio source
/// </summary>
private float[] m_audioReadValue;
/// <summary>
/// Number of samples we read from the audio source
/// </summary>
private int m_samplesCount;
/// <summary>
/// Alpha value for the running average, used to provide smoothing of the volume.
/// Every frame the volume is computed as alpha * currentVolume + (1 - alpha) * newVolume
/// </summary>
private float m_runningAvgAlpha;
/// <summary>
/// The sensitivity of the volume detection
/// </summary>
private float m_volumeSensitivity;
/// <summary>
/// Current volume of the audio
/// </summary>
private float m_currentVolumeValue = 0;
/// <inheritdoc/>
public override float VolumeSensitivity { get => m_volumeSensitivity; set => m_volumeSensitivity = value; }
/// <inheritdoc/>
public override float CurrentVolume
{
get
{
ComputeVolume();
return Mathf.Clamp01(m_currentVolumeValue * VolumeSensitivity);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="volumeSensitivity">Sensitivity of the detection. Higher values means there will be higher values in return for the same audio level</param>
/// <param name="samplesCount">Number of samples to use to compute the volume</param>
/// <param name="runningAvgAlpha">Alpha constant for running average, used for smoothing. Higher values produce more smoothed results</param>
public AudioAnalyzer( | IAudioDataSource audioDataSource, float volumeSensitivity = 10, int samplesCount = 128, float runningAvgAlpha = 0.25f)
{ |
m_audioDataSource = audioDataSource;
m_samplesCount = samplesCount;
m_runningAvgAlpha = runningAvgAlpha;
m_audioReadValue = new float[samplesCount];
m_volumeSensitivity = volumeSensitivity;
}
/// <summary>
/// Computes the volume of the audio source in this moment
/// </summary>
private void ComputeVolume()
{
if (m_audioDataSource == null || !m_audioDataSource.IsPlaying)
return;
//read audio source data and compute the sum of the absolute values
float sum = 0;
for (int c = 0; c < m_audioDataSource.AudioChannels; c++)
{
m_audioDataSource.GetAudioData(m_audioReadValue, c);
for (int i = 0; i < m_audioReadValue.Length; i++)
sum += Mathf.Abs(m_audioReadValue[i]);
}
//compute the running average: alpha * currentVolume + (1 - alpha) * newVolume
m_currentVolumeValue = m_currentVolumeValue * m_runningAvgAlpha + (sum / (m_samplesCount * m_audioDataSource.AudioChannels)) * (1 - m_runningAvgAlpha);
}
}
} | CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioAnalyzer.cs | Perpetual-eMotion-DynaimicApps-46c94e0 | [
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/MicrophoneManager.cs",
"retrieved_chunk": " /// <param name=\"loop\">True to loop the detection after lengthSec is reached</param>\n /// <param name=\"lengthSec\">How many seconds maximum long should be the recorded Audioclip</param>\n /// <param name=\"frequency\">Frequency of the recording</param>\n /// <returns>AudioClip used by the recording microphone. Beware that this will be overwritten by the next recording</returns>\n public AudioClip StartRecording(bool loop = true, int lengthSec = 20, int frequency = 44100)\n {\n if (Microphone.devices.Length == 0)\n {\n Debug.LogWarning(\"No microphone detected. No recording will start\");\n return null;",
"score": 0.8576509952545166
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioDataSources.cs",
"retrieved_chunk": " /// </summary>\n abstract int AudioChannels { get; }\n /// <summary>\n /// Gets the audio data from a specific channel of the audio source\n /// </summary>\n /// <param name=\"data\">Array of data that will be filled by the function</param>\n /// <param name=\"channel\">Channel of interest</param>\n abstract void GetAudioData(float[] data, int channel);\n }\n /// <summary>",
"score": 0.8392217755317688
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioDataSources.cs",
"retrieved_chunk": " /// Interface for elements that provide audio data\n /// </summary>\n public interface IAudioDataSource\n {\n /// <summary>\n /// True if the audio source is playing (so data is available), false otherwise\n /// </summary>\n abstract bool IsPlaying { get; }\n /// <summary>\n /// The number of channels of the audio source",
"score": 0.8365089297294617
},
{
"filename": "CubicMusic/Assets/_DynaimicLogic/Runtime/GenerativeLogic/GenerativeLogicManager.cs",
"retrieved_chunk": " public class AiGenerationParameters\n {\n /// <summary>\n /// Type of completion model to use\n /// </summary>\n public AiCompletionModel CompletionModel { get; set; } = AiCompletionModel.Accurate;\n /// <summary>\n /// Temperature to use for the completion. Higher values will make the AI more creative\n /// </summary>\n public float Temperature { get; set; } = 0.33f;",
"score": 0.8308674693107605
},
{
"filename": "CubicMusic/Assets/_CubicMusic/Runtime/AudioManagement/AudioManager.cs",
"retrieved_chunk": " /// Manages the audio in the application\n /// </summary>\n public class AudioManager : Singleton<AudioManager>\n {\n /// <summary>\n /// The microphone manager to be used by the application\n /// </summary>\n public MicrophoneManager MicrophoneManager { get; private set; }\n /// <summary>\n /// Analyzer of data of the background music. Can be null if there is no background music set.",
"score": 0.8262804746627808
}
] | csharp | IAudioDataSource audioDataSource, float volumeSensitivity = 10, int samplesCount = 128, float runningAvgAlpha = 0.25f)
{ |
using Microsoft.Extensions.Options;
using System;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Net.Http;
namespace HttpMessageHandlerFactory.Implementations
{
/// <summary>
/// HttpMessageHandler创建器
/// </summary>
sealed class HttpMessageHandlerBuilder
{
private readonly IServiceProvider serviceProvider;
private readonly IOptionsMonitor<HttpMessageHandlerOptions> options;
/// <summary>
/// 获取或设置别名和代理
/// </summary>
[NotNull]
public | NameProxy? NameProxy { | get; set; }
/// <summary>
/// 获取生命周期
/// </summary>
/// <returns></returns>
public TimeSpan GetLifetime()
{
return this.options.Get(this.NameProxy.Name).Lifetime;
}
/// <summary>
/// HttpMessageHandler创建器
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="options"></param>
public HttpMessageHandlerBuilder(
IServiceProvider serviceProvider,
IOptionsMonitor<HttpMessageHandlerOptions> options)
{
this.serviceProvider = serviceProvider;
this.options = options;
}
/// <summary>
/// 创建链式调用的<see cref="HttpMessageHandler"/>
/// </summary>
/// <returns></returns>
public HttpMessageHandler Build()
{
var next = this.BuildPrimary();
var additionalHandlers = this.options.Get(this.NameProxy.Name).AdditionalHandlers;
for (var i = additionalHandlers.Count - 1; i >= 0; i--)
{
var handler = additionalHandlers[i](serviceProvider);
handler.InnerHandler = next;
next = handler;
}
return next;
}
/// <summary>
/// 创建基础消息处理者
/// </summary>
/// <returns></returns>
private HttpMessageHandler BuildPrimary()
{
var primaryHandler = new SocketsHttpHandler
{
UseCookies = false
};
var proxyUri = this.NameProxy.ProxyUri;
if (proxyUri == null)
{
primaryHandler.UseProxy = false;
}
else
{
primaryHandler.UseProxy = true;
primaryHandler.Proxy = new WebProxy(proxyUri) { Credentials = GetCredential(proxyUri) };
}
var configures = this.options.Get(this.NameProxy.Name).PrimaryHandlerConfigures;
foreach (var configure in configures)
{
configure(serviceProvider, primaryHandler);
}
return primaryHandler;
}
/// <summary>
/// 获取身份
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private static NetworkCredential? GetCredential(Uri uri)
{
var userInfo = uri.UserInfo;
if (string.IsNullOrEmpty(userInfo))
{
return null;
}
var index = userInfo.IndexOf(':');
if (index < 0)
{
return new NetworkCredential(userInfo, default(string));
}
var username = userInfo[..index];
var password = userInfo[(index + 1)..];
return new NetworkCredential(username, password);
}
}
}
| HttpMessageHandlerFactory/Implementations/HttpMessageHandlerBuilder.cs | xljiulang-HttpMessageHandlerFactory-4b1d13b | [
{
"filename": "HttpMessageHandlerFactory/Implementations/DefaultHttpMessageHandlerFactory.cs",
"retrieved_chunk": " /// </summary>\n sealed class DefaultHttpMessageHandlerFactory : IHttpMessageHandlerFactory\n {\n private readonly NameRegistration nameRegistration;\n private readonly IServiceScopeFactory serviceScopeFactory;\n private readonly ExpiredHandlerEntryCleaner expiredHandlerEntryCleaner;\n /// <summary>\n /// 过期回调\n /// </summary>\n private readonly TimerCallback expiryCallback;",
"score": 0.8894975185394287
},
{
"filename": "HttpMessageHandlerFactory/Implementations/ExpiredHandlerEntry.cs",
"retrieved_chunk": " {\n private readonly WeakReference livenessTracker;\n public bool CanDispose => !livenessTracker.IsAlive;\n public NameProxy NameProxy { get; }\n public IServiceScope ServiceScope { get; }\n /// <summary>\n /// LifetimeHttpHandler的InnerHandler\n /// </summary>\n public HttpMessageHandler InnerHandler { get; }\n /// <summary>",
"score": 0.8602930307388306
},
{
"filename": "HttpMessageHandlerFactory/DependencyInjection/IHttpMessageHandlerBuilder.cs",
"retrieved_chunk": "namespace Microsoft.Extensions.DependencyInjection\n{\n /// <summary>\n /// Http消息处理者创建者\n /// </summary>\n public interface IHttpMessageHandlerBuilder\n {\n /// <summary>\n /// 选项名\n /// </summary>",
"score": 0.8517577052116394
},
{
"filename": "HttpMessageHandlerFactory/DependencyInjection/HttpMessageHandlerBuilderExtensions.cs",
"retrieved_chunk": " return builder;\n }\n /// <summary>\n /// 添加选项\n /// </summary>\n /// <param name=\"builder\"></param>\n /// <returns></returns>\n private static OptionsBuilder<HttpMessageHandlerOptions> AddOptions(this IHttpMessageHandlerBuilder builder)\n {\n return builder.Services.AddOptions<HttpMessageHandlerOptions>(builder.Name);",
"score": 0.8386784195899963
},
{
"filename": "HttpMessageHandlerFactory/DependencyInjection/HttpMessageHandlerBuilderExtensions.cs",
"retrieved_chunk": " /// <summary>\n /// 添加管道HttpMessageHandler\n /// </summary>\n /// <param name=\"builder\"></param>\n /// <param name=\"configureHandler\"></param>\n /// <returns></returns>\n public static IHttpMessageHandlerBuilder AddHttpMessageHandler(this IHttpMessageHandlerBuilder builder, Func<DelegatingHandler> configureHandler)\n {\n return builder.AddHttpMessageHandler(serviceProvider => configureHandler());\n }",
"score": 0.8359776735305786
}
] | csharp | NameProxy? NameProxy { |
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Sandland.SceneTool.Editor.Common.Data;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UIElements;
using Object = UnityEngine.Object;
namespace Sandland.SceneTool.Editor.Common.Utils
{
internal static class AssetDatabaseUtils
{
public static VisualTreeAsset FindAndLoadVisualTreeAsset(string name = null) =>
FindAndLoadAsset<VisualTreeAsset>(name);
public static StyleSheet FindAndLoadStyleSheet(string name = null) => FindAndLoadAsset<StyleSheet>(name);
public static bool TryFindAndLoadAsset<T>(out T result, string name = null) where T : Object
{
try
{
result = FindAndLoadAsset<T>(name);
return true;
}
catch
{
result = null;
return false;
}
}
public static T FindAndLoadAsset<T>(string name = null) where T : Object
{
// TODO: Reuse code from FindAssets
var typeName = typeof(T).Name;
var query = string.IsNullOrEmpty(name) ? $"t:{typeName}" : $"{name} t:{typeName}";
var guids = AssetDatabase.FindAssets(query);
switch (guids.Length)
{
case 0:
throw new FileNotFoundException($"Cant locate {typeName} file with the name: {name}");
case > 1:
Debug.LogWarning(
$"Found more than one {typeName} file with the name: {name}; Loading only the first");
break;
}
var path = AssetDatabase.GUIDToAssetPath(guids.First());
var asset = AssetDatabase.LoadAssetAtPath<T>(path);
if (asset == null)
{
throw new FileNotFoundException($"Unable to load the {typeName} with the name {name}");
}
return asset;
}
public static bool TryFindAssets<T>(out AssetFileInfo[] result, string name = null)
{
try
{
result = FindAssets<T>(name);
return result.Length > 0;
}
catch
{
result = null;
return false;
}
}
public static SceneInfo[] FindScenes(string name = null)
{
var assets = FindAssets<Scene>(name);
var result = new List<SceneInfo>(assets.Length);
var sceneBuildIndexes = Utils.GetSceneBuildIndexes();
var assetsInBundles = Utils.GetAssetsInBundles();
const string packagesPrefix = "Packages/";
foreach (var asset in assets)
{
if (asset.Path.StartsWith(packagesPrefix))
{
continue;
}
SceneInfo info;
if (Utils.IsAssetAddressable(asset.Guid, out var address))
{
info = SceneInfo.Create.Addressable(address, asset.Name, asset.Path, asset.Guid, asset.Labels);
}
else if (Utils.IsAssetInBundle(assetsInBundles, asset.Path, out var bundleName))
{
info = SceneInfo.Create.AssetBundle(asset.Name, asset.Path, asset.Guid, bundleName, asset.Labels);
}
else if (sceneBuildIndexes.ContainsSceneGuid(asset.Guid, out var buildIndex))
{
info = SceneInfo.Create.BuiltIn(asset.Name, buildIndex, asset.Path, asset.Guid, asset.Labels);
}
else
{
info = SceneInfo.Create.Default(asset.Name, asset.Path, asset.Guid, asset.Labels);
}
result.Add(info);
}
return result.ToArray();
}
public static AssetFileInfo[] FindAssets<T>(string name = null)
{
var typeName = typeof(T).Name;
var query = string.IsNullOrEmpty(name) ? $"t:{typeName}" : $"{name} t:{typeName}";
var guids = AssetDatabase.FindAssets(query);
if (guids.Length == 0)
{
return Array.Empty<AssetFileInfo>();
}
var result = new AssetFileInfo[guids.Length];
for (var i = 0; i < guids.Length; i++)
{
var guid = guids[i];
var path = AssetDatabase.GUIDToAssetPath(guid);
var assetName = Path.GetFileNameWithoutExtension(path);
var labels = AssetDatabase.GetLabels(new GUID(guid)).ToList();
result[i] = new AssetFileInfo(assetName, path, guid, string.Empty, labels);
}
return result;
}
public static void SetLabels<T>(this | AssetFileInfo info) where T : Object
{ |
var asset = AssetDatabase.LoadAssetAtPath<T>(info.Path);
AssetDatabase.SetLabels(asset, info.Labels.ToArray());
}
public static void SetLabel<T>(string path, string label) where T : Object
{
var asset = AssetDatabase.LoadAssetAtPath<T>(path);
var labels = AssetDatabase.GetLabels(asset).ToList();
if (labels.Contains(label))
{
return;
}
labels.Add(label);
AssetDatabase.SetLabels(asset, labels.ToArray());
}
}
} | Assets/SceneTools/Editor/Common/Utils/AssetDatabaseUtils.cs | migus88-Sandland.SceneTools-64e9f8c | [
{
"filename": "Assets/SceneTools/Editor/Common/Utils/Utils.cs",
"retrieved_chunk": " public static Dictionary<string, string> GetAssetsInBundles() =>\n AssetDatabase\n .GetAllAssetBundleNames()\n .SelectMany(AssetDatabase.GetAssetPathsFromAssetBundle, (bundleName, path) => new { bundleName, path })\n .ToDictionary(x => x.path, x => x.bundleName);\n public static Dictionary<GUID, int> GetSceneBuildIndexes()\n {\n var collection = new Dictionary<GUID, int>();\n var scenesAmount = EditorBuildSettings.scenes.Length;\n for (var i = 0; i < scenesAmount; i++)",
"score": 0.815224289894104
},
{
"filename": "Assets/SceneTools/Editor/Common/Data/SceneInfo.cs",
"retrieved_chunk": " }\n public static SceneInfo AssetBundle(string name, string path, string guid, string bundleName, List<string> labels = null)\n {\n return new SceneInfo(name, path, guid, bundleName, labels)\n {\n ImportType = SceneImportType.AssetBundle\n };\n }\n public static SceneInfo Default(string name, string path, string guid, List<string> labels = null)\n {",
"score": 0.8139364719390869
},
{
"filename": "Assets/SceneTools/Editor/Common/Utils/Utils.cs",
"retrieved_chunk": " return entry != null;\n }\n Debug.LogError($\"No valid asset path found: {guid}\");\n return false;\n#else\n return false;\n#endif\n }\n public static bool IsAssetInBundle(Dictionary<string, string> assetsInBundles, string assetPath, out string bundleName) \n => assetsInBundles.TryGetValue(assetPath, out bundleName);",
"score": 0.8107410669326782
},
{
"filename": "Assets/SceneTools/Editor/Services/SceneTools/SceneToolsClassGenerationService.cs",
"retrieved_chunk": " {\n var info = AssetDatabase.FindAssets($\"l:{Label}\");\n return info.Length == 0 ? null : AssetDatabase.GUIDToAssetPath(info[0]);\n }\n }\n }\n}",
"score": 0.7935913801193237
},
{
"filename": "Assets/SceneTools/Editor/Common/Data/AssetFileInfo.cs",
"retrieved_chunk": " public AssetFileInfo(string name, string path, string guid, string bundleName, List<string> labels)\n {\n Name = name;\n Path = path;\n Guid = guid;\n BundleName = bundleName;\n Labels = labels;\n }\n }\n}",
"score": 0.7877412438392639
}
] | csharp | AssetFileInfo info) where T : Object
{ |
using EleCho.GoCqHttpSdk;
using EleCho.GoCqHttpSdk.Message;
using EleCho.GoCqHttpSdk.Post;
using NodeBot.Classes;
using NodeBot.Command;
using NodeBot.Event;
using NodeBot.Service;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;
namespace NodeBot
{
public class NodeBot
{
public Dictionary<long, int> Permissions = new();
public int OpPermission = 5;
public CqWsSession session;
public event EventHandler<ConsoleInputEvent>? ConsoleInputEvent;
public event EventHandler<ReceiveMessageEvent>? ReceiveMessageEvent;
public List<ICommand> Commands = new List<ICommand>();
public List<IService> Services = new List<IService>();
public Queue<Task> ToDoQueue = new Queue<Task>();
public NodeBot(string ip)
{
session = new(new()
{
BaseUri = new Uri("ws://" + ip),
UseApiEndPoint = true,
UseEventEndPoint = true,
});
session.PostPipeline.Use(async (context, next) =>
{
if (ReceiveMessageEvent != null)
{
ReceiveMessageEvent(this, new(context));
}
await next();
});
ConsoleInputEvent += (sender, e) =>
{
ExecuteCommand(new ConsoleCommandSender(session, this), e.Text);
};
ReceiveMessageEvent += (sender, e) =>
{
if (e.Context is CqPrivateMessagePostContext cqPrivateMessage)
{
ExecuteCommand(new UserQQSender(session, this, cqPrivateMessage.UserId), cqPrivateMessage.Message);
}
if (e.Context is CqGroupMessagePostContext cqGroupMessage)
{
ExecuteCommand(new GroupQQSender(session ,this, cqGroupMessage.GroupId, cqGroupMessage.UserId), cqGroupMessage.Message);
}
};
}
/// <summary>
/// 保存权限数据
/// </summary>
public void SavePermission()
{
if (!File.Exists("Permission.json"))
{
File.Create("Permission.json").Close();
}
File.WriteAllText("Permission.json", Newtonsoft.Json.JsonConvert.SerializeObject(Permissions));
}
/// <summary>
/// 加载权限数据
/// </summary>
public void LoadPermission()
{
if (File.Exists("Permission.json"))
{
string json = File.ReadAllText("Permission.json");
Permissions = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<long, int>>(json)!;
}
}
public void RegisterCommand(ICommand command)
{
Commands.Add(command);
}
public void RegisterService(IService service)
{
Services.Add(service);
}
public void Start()
{
session.Start();
foreach (IService service in Services)
{
service.OnStart(this);
}
Task.Run(() =>
{
while (true)
{
Thread.Sleep(1000);
if (ToDoQueue.Count > 0)
{
Task task;
lock (ToDoQueue)
{
task = ToDoQueue.Dequeue();
}
task.Start();
}
}
});
}
public void CallConsoleInputEvent(string text)
{
if (ConsoleInputEvent != null)
{
ConsoleInputEvent(this, new(text));
}
}
public void ExecuteCommand(ICommandSender sender, string commandLine)
{
ICommand? command = GetCommandByCommandLine(commandLine);
if (command == null)
{
return;
}
if (sender is ConsoleCommandSender console)
{
if (command.IsConsoleCommand())
{
command.Execute(sender, commandLine);
}
}
}
public void ExecuteCommand( | IQQSender sender, CqMessage commandLine)
{ |
if (commandLine[0] is CqTextMsg cqTextMsg)
{
ICommand? command = GetCommandByCommandLine(cqTextMsg.Text);
if (command == null)
{
return;
}
if (HasPermission(command, sender))
{
if (sender is UserQQSender userQQSender && command.IsUserCommand())
{
command.Execute(sender, commandLine);
}
if (sender is GroupQQSender groupQQSender && command.IsGroupCommand())
{
command.Execute(sender, commandLine);
}
}
else
{
sender.SendMessage("你没有权限");
}
}
}
public ICommand? GetCommandByCommandLine(string command)
{
string[] tmp = command.Split(' ');
foreach (string s in tmp)
{
if (s != string.Empty)
{
return FindCommand(s);
}
}
return null;
}
public ICommand? FindCommand(string commandName)
{
foreach (ICommand command in Commands)
{
if (command.GetName().ToLower() == commandName.ToLower())
{
return command;
}
}
return null;
}
public bool HasPermission(ICommand command, long QQNumber)
{
int permission = 0;
if (Permissions.ContainsKey(QQNumber))
{
permission = Permissions[QQNumber];
}
return permission >= command.GetDefaultPermission();
}
public bool HasPermission(ICommand command, ICommandSender sender)
{
if (sender is IQQSender QQSender)
{
return HasPermission(command, QQSender.GetNumber());
}
if (sender is ConsoleCommandSender)
{
return true;
}
return false;
}
public void RunTask(Task task)
{
lock (ToDoQueue)
{
ToDoQueue.Enqueue(task);
}
}
public void RunAction(Action action)
{
Task task = new(action);
RunTask(task);
}
public void SendGroupMessage(long GroupNumber, CqMessage msgs)
{
RunAction(() =>
{
session.SendGroupMessage(GroupNumber, msgs);
});
}
public void SendPrivateMessage(long QQNumber, CqMessage msgs)
{
RunAction(() =>
{
session.SendPrivateMessage(QQNumber, msgs);
});
}
public void SendMessage(long Number, CqMessage msgs, UserType type)
{
if(type == UserType.User)
{
SendPrivateMessage(Number, msgs);
}
else if(type == UserType.Group)
{
SendGroupMessage(Number, msgs);
}
}
}
}
| NodeBot/NodeBot.cs | Blessing-Studio-NodeBot-ca9921f | [
{
"filename": "NodeBot/Command/Echo.cs",
"retrieved_chunk": " {\n public bool Execute(ICommandSender sender, string commandLine)\n {\n sender.SendMessage(commandLine.TrimStart().Substring(5));\n return true;\n }\n public bool Execute(IQQSender QQSender, CqMessage msgs)\n {\n if (msgs[0] is CqTextMsg msg)\n {",
"score": 0.8965948820114136
},
{
"filename": "NodeBot/github/GithubCommand.cs",
"retrieved_chunk": " public class GithubCommand : ICommand\n {\n public GithubCommand()\n {\n }\n public bool Execute(ICommandSender sender, string commandLine)\n {\n return true;\n }\n public bool Execute(IQQSender QQSender, CqMessage msgs)",
"score": 0.8672571778297424
},
{
"filename": "NodeBot/Command/Stop.cs",
"retrieved_chunk": "{\n public class Stop : ICommand\n {\n public bool Execute(ICommandSender sender, string commandLine)\n {\n sender.SendMessage(\"机器人已停止\");\n Environment.Exit(0);\n return true;\n }\n public bool Execute(IQQSender QQSender, CqMessage msgs)",
"score": 0.8667497038841248
},
{
"filename": "NodeBot/BTD6/BTD6_RoundCheck.cs",
"retrieved_chunk": " }\n msg += $\"\\n\\n==========\";\n sender.SendMessage(msg);\n }\n }\n return true;\n }\n public bool Execute(IQQSender QQSender, CqMessage msgs)\n {\n if (msgs[0] is CqTextMsg msg)",
"score": 0.8533600568771362
},
{
"filename": "NodeBot/Command/AtAll.cs",
"retrieved_chunk": " public class AtAll : ICommand\n {\n public bool Execute(ICommandSender sender, string commandLine)\n {\n throw new NotImplementedException();\n }\n public bool Execute(IQQSender QQSender, CqMessage msgs)\n {\n List<CqAtMsg> tmp = new List<CqAtMsg>();\n foreach(var user in QQSender.GetSession().GetGroupMemberList(QQSender.GetGroupNumber()!.Value)!.Members)",
"score": 0.8462284803390503
}
] | csharp | IQQSender sender, CqMessage commandLine)
{ |
using Word = Microsoft.Office.Interop.Word;
namespace QuizGenerator.Core
{
class RandomizedQuiz
{
public Word.Range HeaderContent { get; set; }
public List<QuizQuestionGroup> QuestionGroups { get; set; }
public Word.Range FooterContent { get; set; }
public IEnumerable< | QuizQuestion> AllQuestions
=> QuestionGroups.SelectMany(g => g.Questions); |
public static RandomizedQuiz GenerateFromQuizData(QuizDocument quizData)
{
// Clone the quiz header, question groups and footer
RandomizedQuiz randQuiz = new RandomizedQuiz();
randQuiz.HeaderContent = quizData.HeaderContent;
randQuiz.FooterContent = quizData.FooterContent;
randQuiz.QuestionGroups = new List<QuizQuestionGroup>();
int questionGroupIndex = 1;
foreach (var questionGroupData in quizData.QuestionGroups)
{
// Copy question groups from quiz data to randQuiz
questionGroupIndex++;
var randQuestionGroup = new QuizQuestionGroup();
randQuiz.QuestionGroups.Add(randQuestionGroup);
randQuestionGroup.HeaderContent = questionGroupData.HeaderContent;
randQuestionGroup.SkipHeader = questionGroupData.SkipHeader;
randQuestionGroup.Questions = new List<QuizQuestion>();
// Check if QuestionsToGenerate is valid number
if (questionGroupData.QuestionsToGenerate > questionGroupData.Questions.Count)
{
throw new Exception("QuestionsToGenerate > questions in group " +
$"#{questionGroupIndex}` - {questionGroupData.HeaderContent?.Text}`");
}
// Generate a randomized subset of questions from the current group
List<int> randomQuestionIndexes =
Enumerable.Range(0, questionGroupData.Questions.Count).ToList();
randomQuestionIndexes = RandomizeList(randomQuestionIndexes);
randomQuestionIndexes = randomQuestionIndexes.Take(
questionGroupData.QuestionsToGenerate).ToList();
foreach (int randQuestionIndex in randomQuestionIndexes)
{
var questionData = questionGroupData.Questions[randQuestionIndex];
QuizQuestion randQuestion = new QuizQuestion();
randQuestionGroup.Questions.Add(randQuestion);
randQuestion.HeaderContent = questionData.HeaderContent;
randQuestion.FooterContent = questionData.FooterContent;
// Generate a randomized subset of answers (1 correct + several wrong)
var correctAnswers = RandomizeList(questionData.CorrectAnswers);
var wrongAnswers = RandomizeList(questionData.WrongAnswers);
// Check if CorrectAnswers is valid number
if (correctAnswers.Count == 0)
{
throw new Exception($"Question `{randQuestion.HeaderContent.Text}` --> " +
$"at least 1 correct answer is required!");
}
// Check if WrongAnswers is valid number
if (wrongAnswers.Count() == 0 ||
wrongAnswers.Count() + 1 < questionGroupData.AnswersPerQuestion)
{
throw new Exception($"Question `{randQuestion.HeaderContent.Text}` --> " +
$"wrong answers are less than required!");
}
List<QuestionAnswer> randAnswers =
wrongAnswers.Take(questionGroupData.AnswersPerQuestion - 1)
.Append(correctAnswers.First())
.ToList();
randQuestion.Answers = RandomizeList(randAnswers);
}
}
return randQuiz;
}
private static List<T> RandomizeList<T>(IEnumerable<T> inputList)
{
// Randomize the list using Fisher-Yates shuffle algorithm
List<T> list = new List<T>(inputList);
Random rand = new Random();
int lastIndex = list.Count;
while (lastIndex > 1)
{
lastIndex--;
int randIndex = rand.Next(lastIndex + 1);
T value = list[randIndex];
list[randIndex] = list[lastIndex];
list[lastIndex] = value;
}
return list;
}
}
}
| QuizGenerator.Core/RandomizedQuiz.cs | SoftUni-SoftUni-Quiz-Generator-b071448 | [
{
"filename": "QuizGenerator.Core/QuizQuestionGroup.cs",
"retrieved_chunk": "using Word = Microsoft.Office.Interop.Word;\nnamespace QuizGenerator.Core\n{\n\tclass QuizQuestionGroup\n\t{\n\t\tpublic int QuestionsToGenerate { get; set; }\n\t\tpublic int AnswersPerQuestion { get; set; }\n\t\tpublic bool SkipHeader { get; set; }\n\t\tpublic Word.Range HeaderContent { get; set; }\n\t\tpublic List<QuizQuestion> Questions { get; set; }",
"score": 0.929985523223877
},
{
"filename": "QuizGenerator.Core/QuizQuestion.cs",
"retrieved_chunk": "using Word = Microsoft.Office.Interop.Word;\nnamespace QuizGenerator.Core\n{\n\tclass QuizQuestion\n\t{\n\t\tpublic Word.Range HeaderContent { get; set; }\n\t\tpublic List<QuestionAnswer> Answers { get; set; }\n\t\tpublic IEnumerable<QuestionAnswer> CorrectAnswers =>\n\t\t\tthis.Answers.Where(a => a.IsCorrect);\n\t\tpublic IEnumerable<QuestionAnswer> WrongAnswers =>",
"score": 0.9201677441596985
},
{
"filename": "QuizGenerator.Core/QuizDocument.cs",
"retrieved_chunk": "using Word = Microsoft.Office.Interop.Word;\nnamespace QuizGenerator.Core\n{\n\tclass QuizDocument\n\t{\n\t\tpublic int VariantsToGenerate { get; set; }\n\t\tpublic string LangCode { get; set; } = \"EN\";\n public int AnswersPerQuestion { get; set; }\n\t\tpublic int TotalAvailableQuestions\n\t\t\t=> QuestionGroups.Sum(g => g.Questions.Count);",
"score": 0.9044883847236633
},
{
"filename": "QuizGenerator.Core/QuizDocument.cs",
"retrieved_chunk": "\t\tpublic int TotalQuestionsToGenerate\n\t\t\t=> QuestionGroups.Sum(g => g.QuestionsToGenerate);\n\t\tpublic Word.Range HeaderContent { get; set; }\n public List<QuizQuestionGroup> QuestionGroups { get; set; }\n public Word.Range FooterContent { get; set; }\n }\n}",
"score": 0.8825511932373047
},
{
"filename": "QuizGenerator.Core/QuestionAnswer.cs",
"retrieved_chunk": "using Word = Microsoft.Office.Interop.Word;\nnamespace QuizGenerator.Core\n{\n\tclass QuestionAnswer\n\t{\n\t\tpublic Word.Range Content { get; set; }\n public bool IsCorrect { get; set; }\n }\n}",
"score": 0.8723382353782654
}
] | csharp | QuizQuestion> AllQuestions
=> QuestionGroups.SelectMany(g => g.Questions); |
using ECS.ComponentsAndTags;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
namespace ECS.Systems
{
/// <summary>
/// This system matches random rival units
/// </summary>
[UpdateAfter(typeof( | InitializeUnitsSystem))]
public partial class AssignTargetSystem : SystemBase
{ |
protected override void OnCreate()
{
base.OnCreate();
Enabled = false;
GameManager.GameStarted += OnGameStarted;
GameManager.GameReloaded += OnGameReloaded;
}
private void OnGameReloaded()
{
Enabled = false;
}
/// <summary>
/// Before the game start we don't this system to match any unit
/// </summary>
private void OnGameStarted()
{
Enabled = true;
}
protected override void OnUpdate()
{
var random = new Random((uint)UnityEngine.Random.Range(1, int.MaxValue));
EntityQuery query = EntityManager.CreateEntityQuery(typeof(TeamComponent));
NativeArray<Entity> entities = query.ToEntityArray(Allocator.TempJob);
// Create a NativeList to store entities with a specific component
// This doesn't need to be parallel
var redUnits = new NativeList<Entity>(Allocator.TempJob);
var blueUnits = new NativeList<Entity>(Allocator.TempJob);
Entities
.ForEach((Entity entity, in TeamComponent teamComponent) =>
{
switch (teamComponent.value)
{
case Team.Blue:
blueUnits.Add(entity);
break;
case Team.Red:
redUnits.Add(entity);
break;
default:
break;
}
}).Run();
// Using async programming to handle random unit match
Entities
.WithAll<TargetComponent>()
.WithAll<TeamComponent>()
.WithReadOnly(redUnits)
.WithReadOnly(blueUnits)
.ForEach((Entity entity, int entityInQueryIndex, ref TargetComponent target, in TeamComponent team) =>
{
if (entities.Contains(target.value))
{
return;
}
int targetCount;
int randomIndex;
switch (team.value)
{
case Team.Blue:
if (redUnits.Length <= 0)
{
return;
}
targetCount = redUnits.Length;
randomIndex = random.NextInt(0, targetCount);
target.value = redUnits[randomIndex];
break;
case Team.Red:
if (blueUnits.Length <= 0)
{
return;
}
targetCount = blueUnits.Length;
randomIndex = random.NextInt(0, targetCount);
target.value = blueUnits[randomIndex];
break;
default:
break;
}
}).ScheduleParallel();
}
}
} | Assets/Scripts/ECS/Systems/AssignTargetSystem.cs | aknkrstozkn-BattleSimulator-DOTS-48e9e68 | [
{
"filename": "Assets/Scripts/ECS/Systems/UpdateHealthDisplaySystem.cs",
"retrieved_chunk": "using ECS.ComponentsAndTags;\nusing Unity.Entities;\nusing UnityEngine;\nnamespace ECS.Systems\n{\n\t/// <summary>\n\t/// Updated health texts of units\n\t/// </summary>\n\t[UpdateAfter(typeof(InitializeUnitsSystem))]\n\tpublic partial class UpdateHealthDisplaySystem : SystemBase",
"score": 0.8786242008209229
},
{
"filename": "Assets/Scripts/ECS/Systems/DeathSystem.cs",
"retrieved_chunk": "using ECS.ComponentsAndTags;\nusing Unity.Entities;\nnamespace ECS.Systems\n{\n\t/// <summary>\n\t/// This systems checks if an entities hp below or equal zero to destroy it.\n\t/// </summary>\n\t[UpdateAfter(typeof(ECS.Systems.AttackSystem))]\n\tpublic partial class DeathSystem : SystemBase\n\t{",
"score": 0.8580461144447327
},
{
"filename": "Assets/Scripts/ECS/ComponentsAndTags/TargetComponent.cs",
"retrieved_chunk": "using System;\nusing Unity.Entities;\nnamespace ECS.ComponentsAndTags\n{\n\t/// <summary>\n\t/// Unit component to hold target entity\n\t/// </summary>\n\t[Serializable]\n\tpublic struct TargetComponent : IComponentData\n\t{",
"score": 0.843509316444397
},
{
"filename": "Assets/Scripts/ECS/ComponentsAndTags/DisplayComponent.cs",
"retrieved_chunk": "using System;\nusing Unity.Entities;\nnamespace ECS.ComponentsAndTags\n{\n\t/// <summary>\n\t/// A Unit component to hold TextMesh entity\n\t/// </summary>\n\t[Serializable]\n\tpublic struct DisplayComponent : IComponentData\n\t{",
"score": 0.8324600458145142
},
{
"filename": "Assets/Scripts/ECS/ComponentsAndTags/DisplayParentComponent.cs",
"retrieved_chunk": "using System;\nusing Unity.Entities;\nnamespace ECS.ComponentsAndTags\n{\n\t/// <summary>\n\t/// TextMesh entity component to hold parent unit\n\t/// </summary>\n\t[Serializable]\n\tpublic struct DisplayParentComponent : IComponentData\n\t{",
"score": 0.8290653228759766
}
] | csharp | InitializeUnitsSystem))]
public partial class AssignTargetSystem : SystemBase
{ |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace APIServer
{
public class LoginServer
{
public static | ServerOption ServerOpt; |
static public void Init(string[] args)
{
ServerOpt = (CommandLine.Parser.Default.ParseArguments<ServerOption>(args) as CommandLine.Parsed<ServerOption>).Value;
DBRedis.Init(ServerOpt.RedisName, ServerOpt.RedisAddress);
}
}
}
| cpp/Demo_2020-02-15/APIServer/LoginServer.cs | jacking75-how_to_use_redis_lib-d3accba | [
{
"filename": "cpp/Demo_2020-02-15/Client/Packet.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\nnamespace csharp_test_client\n{\n #region LoginServer \n public class LoginReqJson\n {",
"score": 0.9234297275543213
},
{
"filename": "cpp/Demo_2020-02-15/APIServer/ServerOptions.cs",
"retrieved_chunk": "using CommandLine;\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nnamespace APIServer\n{\n public class ServerOption\n {\n [Option(\"redisName\", Required = true, HelpText = \"Redis Server Name\")]",
"score": 0.909774661064148
},
{
"filename": "cpp/Demo_2020-02-15/APIServer/DBRedis.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing CloudStructures;\nusing CloudStructures.Structures;\nnamespace APIServer\n{\n public class DBRedis {\n public static RedisConnection Connection { get; set; }",
"score": 0.9065759778022766
},
{
"filename": "cpp/Demo_2020-02-15/Client/PacketBufferManager.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\nnamespace csharp_test_client\n{\n class PacketBufferManager\n {\n int BufferSize = 0;",
"score": 0.900183916091919
},
{
"filename": "csharp/redisTest/Program.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing System.Windows.Forms;\nnamespace csharp_test_client\n{\n static class Program\n {\n /// <summary>",
"score": 0.9000470042228699
}
] | csharp | ServerOption ServerOpt; |
namespace ServiceSelf
{
/// <summary>
/// windows独有的服务选项
/// </summary>
public sealed class WindowsServiceOptions
{
/// <summary>
/// 在服务控制管理器中显示的服务名称
/// </summary>
public string? DisplayName { get; set; }
/// <summary>
/// 一个空格分隔的依赖项列表
/// 如果服务依赖于其他服务，则应在此处列出这些服务的名称
/// </summary>
public string? Dependencies { get; set; }
/// <summary>
/// 服务运行的帐户名称。如果不指定，则默认为LocalSystem账户
/// </summary>
public string? ServiceStartName { get; set; }
/// <summary>
/// 与ServiceStartName帐户相关联的密码。如果ServiceStartName为NULL，则此参数被忽略
/// </summary>
public string? Password { get; set; }
/// <summary>
/// 服务故障后的操作类型
/// </summary>
public | WindowsServiceActionType FailureActionType { | get; set; }
}
}
| ServiceSelf/WindowsServiceOptions.cs | xljiulang-ServiceSelf-7f8604b | [
{
"filename": "ServiceSelf/Service.cs",
"retrieved_chunk": " /// 获取服务名\n /// </summary>\n public string Name { get; }\n /// <summary>\n /// 服务\n /// </summary>\n /// <param name=\"name\">服务名</param> \n public Service(string name)\n {\n this.Name = name;",
"score": 0.8510230779647827
},
{
"filename": "ServiceSelf/WindowsServiceActionType.cs",
"retrieved_chunk": "namespace ServiceSelf\n{\n /// <summary>\n /// windows服务操作类型\n /// </summary>\n public enum WindowsServiceActionType\n {\n /// <summary>\n /// 表示不执行任何操作\n /// </summary>",
"score": 0.8475327491760254
},
{
"filename": "ServiceSelf/ServiceOptions.cs",
"retrieved_chunk": " /// <summary>\n /// 获取仅适用于linux的选项\n /// </summary>\n public LinuxServiceOptions Linux { get; } = new LinuxServiceOptions();\n /// <summary>\n /// 获取仅适用于windows的选项\n /// </summary>\n public WindowsServiceOptions Windows { get; } = new WindowsServiceOptions();\n }\n}",
"score": 0.8384795188903809
},
{
"filename": "ServiceSelf/Service.cs",
"retrieved_chunk": " }\n /// <summary>\n /// 创建并启动服务\n /// </summary>\n /// <param name=\"filePath\">文件完整路径</param>\n /// <param name=\"options\">服务选项</param> \n public abstract void CreateStart(string filePath, ServiceOptions options);\n /// <summary>\n /// 停止并删除服务\n /// </summary>",
"score": 0.8276618123054504
},
{
"filename": "ServiceSelf/NamedPipeClient.cs",
"retrieved_chunk": " private readonly CancellationTokenSource disposeTokenSource = new();\n /// <summary>\n /// 当前是否支持写入\n /// </summary>\n public bool CanWrite => this.instance.CanWrite;\n /// <summary>\n /// 命名管道客户端\n /// </summary>\n /// <param name=\"pipeName\"></param>\n public NamedPipeClient(string pipeName)",
"score": 0.8259121179580688
}
] | csharp | WindowsServiceActionType FailureActionType { |
#nullable enable
using UnityEngine;
namespace Mochineko.FacialExpressions.LipSync
{
/// <summary>
/// An implementation of <see cref="IFramewiseLipAnimator"/> to animate lip by audio volume.
/// </summary>
public sealed class VolumeBasedLipAnimator : IFramewiseLipAnimator
{
private readonly ILipMorpher morpher;
private readonly Viseme viseme;
private readonly AudioSource audioSource;
private readonly float smoothTime;
private readonly float volumeMultiplier;
private readonly float[] audioSamples;
private float currentVolume = 0f;
private float velocity = 0f;
/// <summary>
/// Creates a new instance of <see cref="VolumeBasedLipAnimator"/>.
/// </summary>
/// <param name="morpher">Target morpher.</param>
/// <param name="viseme">Target viseme to morph.</param>
/// <param name="audioSource">Audio source to get volume.</param>
/// <param name="smoothTime">Smooth time of volume.</param>
/// <param name="volumeMultiplier">Multiplier of volume.</param>
/// <param name="samplesCount">Count of samples to get volume at each frame.</param>
public VolumeBasedLipAnimator(
ILipMorpher morpher,
Viseme viseme,
AudioSource audioSource,
float smoothTime = 0.1f,
float volumeMultiplier = 1f,
int samplesCount = 1024)
{
if (smoothTime <= 0f)
{
throw new System.ArgumentOutOfRangeException(
nameof(smoothTime), smoothTime,
"Smooth time must be greater than 0.");
}
if (volumeMultiplier <= 0f)
{
throw new System.ArgumentOutOfRangeException(
nameof(volumeMultiplier), volumeMultiplier,
"Volume multiplier must be greater than 0.");
}
if (samplesCount <= 0)
{
throw new System.ArgumentOutOfRangeException(
nameof(samplesCount), samplesCount,
"Samples count must be greater than 0.");
}
this.morpher = morpher;
this.viseme = viseme;
this.audioSource = audioSource;
this.smoothTime = smoothTime;
this.volumeMultiplier = volumeMultiplier;
this.audioSamples = new float[samplesCount];
}
public void Update()
{
morpher.MorphInto(GetSample());
}
public void Reset()
{
morpher.Reset();
}
private | LipSample GetSample()
{ |
audioSource.GetOutputData(audioSamples, channel: 0);
var volume = CalculateVolume(audioSamples);
currentVolume = Mathf.SmoothDamp(
current: currentVolume,
target: volume,
currentVelocity: ref velocity,
smoothTime: smoothTime
);
return new LipSample(
viseme,
Mathf.Clamp01(currentVolume * volumeMultiplier)
);
}
private static float CalculateVolume(float[] samples)
{
var sum = 0f;
foreach (var sample in samples)
{
sum += sample * sample;
}
return Mathf.Sqrt(sum / samples.Length); // Root mean square
}
}
}
| Assets/Mochineko/FacialExpressions/LipSync/VolumeBasedLipAnimator.cs | mochi-neko-facial-expressions-unity-ab0d020 | [
{
"filename": "Assets/Mochineko/FacialExpressions/LipSync/FollowingLipAnimator.cs",
"retrieved_chunk": " }\n public void Reset()\n {\n morpher.Reset();\n }\n }\n}",
"score": 0.8756651282310486
},
{
"filename": "Assets/Mochineko/FacialExpressions.Extensions/uLipSync/ULipSyncAnimator.cs",
"retrieved_chunk": " followingLipAnimator.Update();\n }\n public void Reset()\n {\n followingLipAnimator.Reset();\n }\n private void SetTarget(LipSample sample)\n {\n foreach (var viseme in phonomeMap.Values)\n {",
"score": 0.8734627962112427
},
{
"filename": "Assets/Mochineko/FacialExpressions.Extensions/uLipSync/ULipSyncAnimator.cs",
"retrieved_chunk": " }\n });\n }\n public void Dispose()\n {\n Reset();\n disposable.Dispose();\n }\n public void Update()\n {",
"score": 0.8512653112411499
},
{
"filename": "Assets/Mochineko/FacialExpressions/Emotion/SkinnedMeshEmotionMorpher.cs",
"retrieved_chunk": " }\n else\n {\n return 0f;\n }\n }\n public void Reset()\n {\n foreach (var index in indexMap.Values)\n {",
"score": 0.8252959251403809
},
{
"filename": "Assets/Mochineko/FacialExpressions.Samples/VolumeBasedLipSyncSample.cs",
"retrieved_chunk": " }\n private void Update()\n {\n lipAnimator?.Update();\n emotionAnimator?.Update();\n }\n private void OnDestroy()\n {\n if (audioClip != null)\n {",
"score": 0.8203949332237244
}
] | csharp | LipSample GetSample()
{ |
using HarmonyLib;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using ULTRAKILL.Cheats;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace Ultrapain.Patches
{
public class V2SecondFlag : MonoBehaviour
{
public V2RocketLauncher rocketLauncher;
public V2MaliciousCannon maliciousCannon;
public Collider v2collider;
public Transform targetGrenade;
}
public class V2RocketLauncher : MonoBehaviour
{
public Transform shootPoint;
public Collider v2collider;
AudioSource aud;
float altFireCharge = 0f;
bool altFireCharging = false;
void Awake()
{
aud = GetComponent<AudioSource>();
if (aud == null)
aud = gameObject.AddComponent<AudioSource>();
aud.playOnAwake = false;
aud.clip = Plugin.cannonBallChargeAudio;
}
void Update()
{
if (altFireCharging)
{
if (!aud.isPlaying)
{
aud.pitch = Mathf.Min(1f, altFireCharge) + 0.5f;
aud.Play();
}
altFireCharge += Time.deltaTime;
}
}
void OnDisable()
{
altFireCharging = false;
}
void PrepareFire()
{
Instantiate<GameObject>(Plugin.v2flashUnparryable, this.shootPoint.position, this.shootPoint.rotation).transform.localScale *= 4f;
}
void SetRocketRotation(Transform rocket)
{
// OLD PREDICTION
/*Rigidbody rb = rocket.GetComponent<Rigidbody>();
Grenade grn = rocket.GetComponent<Grenade>();
float magnitude = grn.rocketSpeed;
//float distance = Vector3.Distance(MonoSingleton<PlayerTracker>.Instance.gameObject.transform.position, __0.transform.position);
float distance = Vector3.Distance(MonoSingleton<PlayerTracker>.Instance.GetTarget().position, rocket.transform.position);
Vector3 predictedPosition = MonoSingleton<PlayerTracker>.Instance.PredictPlayerPosition(1.0f);
float velocity = Mathf.Clamp(distance, Mathf.Max(magnitude - 5.0f, 0), magnitude + 5);
rocket.transform.LookAt(predictedPosition);
rocket.GetComponent<Grenade>().rocketSpeed = velocity;
rb.maxAngularVelocity = velocity;
rb.velocity = Vector3.zero;
rb.AddRelativeForce(Vector3.forward * magnitude * rb.mass, ForceMode.VelocityChange);
// rb.velocity = rocket.transform.forward * velocity;
*/
// NEW PREDICTION
Vector3 playerPos = Tools.PredictPlayerPosition(0.5f);
rocket.LookAt(playerPos);
Rigidbody rb = rocket.GetComponent<Rigidbody>();
rb.velocity = Vector3.zero;
rb.AddForce(rocket.transform.forward * 10000f);
}
void Fire()
{
GameObject rocket = Instantiate<GameObject>(Plugin.rocket, shootPoint.transform.position, shootPoint.transform.rotation);
rocket.transform.position = new Vector3(rocket.transform.position.x, v2collider.bounds.center.y, rocket.transform.position.z);
rocket.transform.LookAt(PlayerTracker.Instance.GetTarget());
rocket.transform.position += rocket.transform.forward * 2f;
SetRocketRotation(rocket.transform);
Grenade component = rocket.GetComponent<Grenade>();
if (component)
{
component.harmlessExplosion = component.explosion;
component.enemy = true;
component.CanCollideWithPlayer(true);
}
//Physics.IgnoreCollision(rocket.GetComponent<Collider>(), v2collider);
}
void PrepareAltFire()
{
altFireCharging = true;
}
void AltFire()
{
altFireCharging = false;
altFireCharge = 0;
GameObject cannonBall = Instantiate(Plugin.cannonBall, shootPoint.transform.position, shootPoint.transform.rotation);
cannonBall.transform.position = new Vector3(cannonBall.transform.position.x, v2collider.bounds.center.y, cannonBall.transform.position.z);
cannonBall.transform.LookAt(PlayerTracker.Instance.GetTarget());
cannonBall.transform.position += cannonBall.transform.forward * 2f;
if(cannonBall.TryGetComponent<Cannonball>(out Cannonball comp))
{
comp.sourceWeapon = this.gameObject;
}
if(cannonBall.TryGetComponent<Rigidbody>(out Rigidbody rb))
{
rb.velocity = rb.transform.forward * 150f;
}
}
static MethodInfo bounce = typeof(Cannonball).GetMethod("Bounce", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
public static bool CannonBallTriggerPrefix(Cannonball __instance, Collider __0)
{
if(__instance.sourceWeapon != null && __instance.sourceWeapon.GetComponent<V2RocketLauncher>() != null)
{
if (__0.gameObject.tag == "Player")
{
if (!__instance.hasBounced)
{
bounce.Invoke(__instance, new object[0]);
NewMovement.Instance.GetHurt((int)__instance.damage, true, 1, false, false);
return false;
}
}
else
{
EnemyIdentifierIdentifier eii = __0.gameObject.GetComponent<EnemyIdentifierIdentifier>();
if (!__instance.launched && eii != null && (eii.eid.enemyType == EnemyType.V2 || eii.eid.enemyType == EnemyType.V2Second))
return false;
}
return true;
}
return true;
}
}
public class V2MaliciousCannon : MonoBehaviour
{
//readonly static FieldInfo maliciousIgnorePlayer = typeof(RevolverBeam).GetField("maliciousIgnorePlayer", BindingFlags.NonPublic | BindingFlags.Instance);
Transform shootPoint;
public Transform v2trans;
public float cooldown = 0f;
static readonly string debugTag = "[V2][MalCannonShoot]";
void Awake()
{
shootPoint = UnityUtils.GetChildByNameRecursively(transform, "Shootpoint");
}
void PrepareFire()
{
Instantiate<GameObject>(Plugin.v2flashUnparryable, this.shootPoint.position, this.shootPoint.rotation).transform.localScale *= 4f;
}
void Fire()
{
cooldown = ConfigManager.v2SecondMalCannonSnipeCooldown.value;
Transform target = V2Utils.GetClosestGrenade();
Vector3 targetPosition = Vector3.zero;
if (target != null)
{
Debug.Log($"{debugTag} Targeted grenade");
targetPosition = target.position;
}
else
{
Transform playerTarget = PlayerTracker.Instance.GetTarget();
/*if (Physics.Raycast(new Ray(playerTarget.position, Vector3.down), out RaycastHit hit, 100f, new LayerMask() { value = (1 << 8 | 1 << 24) }, QueryTriggerInteraction.Ignore))
{
Debug.Log($"{debugTag} Targeted ground below player");
targetPosition = hit.point;
}
else
{*/
Debug.Log($"{debugTag} Targeted player with random spread");
targetPosition = playerTarget.transform.position + UnityEngine.Random.onUnitSphere * 2f;
//}
}
GameObject beam = Instantiate(Plugin.maliciousCannonBeam, v2trans.position, Quaternion.identity);
beam.transform.position = new Vector3(beam.transform.position.x, v2trans.GetComponent<Collider>().bounds.center.y, beam.transform.position.z);
beam.transform.LookAt(targetPosition);
beam.transform.position += beam.transform.forward * 2f;
if (beam.TryGetComponent<RevolverBeam>(out RevolverBeam comp))
{
comp.alternateStartPoint = shootPoint.transform.position;
comp.ignoreEnemyType = EnemyType.V2Second;
comp.sourceWeapon = gameObject;
//comp.beamType = BeamType.Enemy;
//maliciousIgnorePlayer.SetValue(comp, false);
}
}
void PrepareAltFire()
{
}
void AltFire()
{
}
}
class V2SecondUpdate
{
static bool Prefix(V2 __instance, ref int ___currentWeapon, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb, ref float ___shootCooldown,
ref bool ___aboutToShoot, ref EnemyIdentifier ___eid, bool ___escaping)
{
if (!__instance.secondEncounter)
return true;
if (!__instance.active || ___escaping || BlindEnemies.Blind)
return true;
V2SecondFlag flag = __instance.GetComponent<V2SecondFlag>();
if (flag == null)
return true;
if (flag.maliciousCannon.cooldown > 0)
flag.maliciousCannon.cooldown = Mathf.MoveTowards(flag.maliciousCannon.cooldown, 0, Time.deltaTime);
if (flag.targetGrenade == null)
{
Transform target = V2Utils.GetClosestGrenade();
//if (ConfigManager.v2SecondMalCannonSnipeToggle.value && target != null
// && ___shootCooldown <= 0.9f && !___aboutToShoot && flag.maliciousCannon.cooldown == 0f)
if(target != null)
{
float distanceToPlayer = Vector3.Distance(target.position, PlayerTracker.Instance.GetTarget().transform.position);
float distanceToV2 = Vector3.Distance(target.position, flag.v2collider.bounds.center);
if (ConfigManager.v2SecondMalCannonSnipeToggle.value && flag.maliciousCannon.cooldown == 0 && distanceToPlayer <= ConfigManager.v2SecondMalCannonSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondMalCannonSnipeMinDistanceToV2.value)
{
flag.targetGrenade = target;
___shootCooldown = 1f;
___aboutToShoot = true;
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
__instance.CancelInvoke("ShootWeapon");
__instance.CancelInvoke("AltShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondMalCannonSnipeReactTime.value / ___eid.totalSpeedModifier);
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[1] { 4 });
}
else if(ConfigManager.v2SecondCoreSnipeToggle.value && distanceToPlayer <= ConfigManager.v2SecondCoreSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondCoreSnipeMinDistanceToV2.value)
{
flag.targetGrenade = target;
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
__instance.CancelInvoke("ShootWeapon");
__instance.CancelInvoke("AltShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondCoreSnipeReactionTime.value / ___eid.totalSpeedModifier);
___shootCooldown = 1f;
___aboutToShoot = true;
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[1] { 0 });
Debug.Log("Preparing to fire for grenade");
}
}
}
return true;
}
}
class V2SecondShootWeapon
{
static bool Prefix(V2 __instance, ref int ___currentWeapon)
{
if (!__instance.secondEncounter)
return true;
V2SecondFlag flag = __instance.GetComponent<V2SecondFlag>();
if (flag == null)
return true;
if (___currentWeapon == 0)
{
//Transform closestGrenade = V2Utils.GetClosestGrenade();
Transform closestGrenade = flag.targetGrenade;
if (closestGrenade != null && ConfigManager.v2SecondCoreSnipeToggle.value)
{
float distanceToPlayer = Vector3.Distance(closestGrenade.position, PlayerTracker.Instance.GetTarget().position);
float distanceToV2 = Vector3.Distance(closestGrenade.position, flag.v2collider.bounds.center);
if (distanceToPlayer <= ConfigManager.v2SecondCoreSnipeMaxDistanceToPlayer.value && distanceToV2 >= ConfigManager.v2SecondCoreSnipeMinDistanceToV2.value)
{
Debug.Log("Attempting to shoot the grenade");
GameObject revolverBeam = GameObject.Instantiate(Plugin.revolverBeam, __instance.transform.position + __instance.transform.forward, Quaternion.identity);
revolverBeam.transform.LookAt(closestGrenade.position);
if (revolverBeam.TryGetComponent<RevolverBeam>(out RevolverBeam comp))
{
comp.beamType = BeamType.Enemy;
comp.sourceWeapon = __instance.weapons[0];
}
__instance.ForceDodge(V2Utils.GetDirectionAwayFromTarget(flag.v2collider.bounds.center, closestGrenade.transform.position));
return false;
}
}
}
else if(___currentWeapon == 4)
{
__instance.ForceDodge(V2Utils.GetDirectionAwayFromTarget(flag.v2collider.bounds.center, PlayerTracker.Instance.GetTarget().position));
}
return true;
}
static void Postfix(V2 __instance, ref int ___currentWeapon)
{
if (!__instance.secondEncounter)
return;
if (___currentWeapon == 4)
{
V2SecondSwitchWeapon.SwitchWeapon.Invoke(__instance, new object[] { 0 });
}
}
}
class V2SecondSwitchWeapon
{
public static MethodInfo SwitchWeapon = typeof(V2).GetMethod("SwitchWeapon", BindingFlags.Instance | BindingFlags.NonPublic);
static bool Prefix(V2 __instance, ref int __0)
{
if (!__instance.secondEncounter || !ConfigManager.v2SecondRocketLauncherToggle.value)
return true;
if (__0 != 1 && __0 != 2)
return true;
int[] weapons = new int[] { 1, 2, 3 };
int weapon = weapons[UnityEngine.Random.RandomRangeInt(0, weapons.Length)];
__0 = weapon;
return true;
}
}
class V2SecondFastCoin
{
static MethodInfo switchWeapon = typeof(V2).GetMethod("SwitchWeapon", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static bool Prefix(V2 __instance, ref int ___coinsToThrow, ref bool ___aboutToShoot, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb,
ref Transform ___target, Animator ___anim, ref bool ___shootingForCoin, ref int ___currentWeapon, ref float ___shootCooldown, ref bool ___aiming)
{
if (___coinsToThrow == 0)
{
return false;
}
GameObject gameObject = GameObject.Instantiate<GameObject>(__instance.coin, __instance.transform.position, __instance.transform.rotation);
Rigidbody rigidbody;
if (gameObject.TryGetComponent<Rigidbody>(out rigidbody))
{
rigidbody.AddForce((___target.transform.position - ___anim.transform.position).normalized * 20f + Vector3.up * 30f, ForceMode.VelocityChange);
}
Coin coin;
if (gameObject.TryGetComponent<Coin>(out coin))
{
GameObject gameObject2 = GameObject.Instantiate<GameObject>(coin.flash, coin.transform.position, MonoSingleton<CameraController>.Instance.transform.rotation);
gameObject2.transform.localScale *= 2f;
gameObject2.transform.SetParent(gameObject.transform, true);
}
___coinsToThrow--;
___aboutToShoot = true;
___shootingForCoin = true;
switchWeapon.Invoke(__instance, new object[1] { 0 });
__instance.CancelInvoke("ShootWeapon");
__instance.Invoke("ShootWeapon", ConfigManager.v2SecondFastCoinShootDelay.value);
___overrideTarget = coin.transform;
___overrideTargetRb = coin.GetComponent<Rigidbody>();
__instance.CancelInvoke("AltShootWeapon");
__instance.weapons[___currentWeapon].transform.GetChild(0).SendMessage("CancelAltCharge", SendMessageOptions.DontRequireReceiver);
___shootCooldown = 1f;
__instance.CancelInvoke("ThrowCoins");
__instance.Invoke("ThrowCoins", ConfigManager.v2SecondFastCoinThrowDelay.value);
return false;
}
}
class V2SecondEnrage
{
static void Postfix( | BossHealthBar __instance, ref EnemyIdentifier ___eid, ref int ___currentHpSlider)
{ |
V2 v2 = __instance.GetComponent<V2>();
if (v2 != null && v2.secondEncounter && ___currentHpSlider == 1)
v2.Invoke("Enrage", 0.01f);
}
}
class V2SecondStart
{
static void RemoveAlwaysOnTop(Transform t)
{
foreach (Transform child in UnityUtils.GetComponentsInChildrenRecursively<Transform>(t))
{
child.gameObject.layer = Physics.IgnoreRaycastLayer;
}
t.gameObject.layer = Physics.IgnoreRaycastLayer;
}
static FieldInfo machineV2 = typeof(Machine).GetField("v2", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
static void Postfix(V2 __instance, EnemyIdentifier ___eid)
{
if (!__instance.secondEncounter)
return;
V2SecondFlag flag = __instance.gameObject.AddComponent<V2SecondFlag>();
flag.v2collider = __instance.GetComponent<Collider>();
/*___eid.enemyType = EnemyType.V2Second;
___eid.UpdateBuffs();
machineV2.SetValue(__instance.GetComponent<Machine>(), __instance);*/
GameObject player = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Player").FirstOrDefault();
if (player == null)
return;
Transform v2WeaponTrans = __instance.weapons[0].transform.parent;
GameObject v2rocketLauncher = GameObject.Instantiate(Plugin.rocketLauncherAlt, v2WeaponTrans);
v2rocketLauncher.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
v2rocketLauncher.transform.localPosition = new Vector3(0.1f, -0.2f, -0.1f);
v2rocketLauncher.transform.localRotation = Quaternion.Euler(new Vector3(10.2682f, 12.6638f, 198.834f));
v2rocketLauncher.transform.GetChild(0).localPosition = Vector3.zero;
v2rocketLauncher.transform.GetChild(0).localRotation = Quaternion.Euler(Vector3.zero);
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<RocketLauncher>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponIdentifier>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<WeaponPos>());
GameObject.DestroyImmediate(v2rocketLauncher.GetComponent<Animator>());
V2RocketLauncher rocketComp = v2rocketLauncher.transform.GetChild(0).gameObject.AddComponent<V2RocketLauncher>();
rocketComp.v2collider = __instance.GetComponent<Collider>();
rocketComp.shootPoint = __instance.transform;
RemoveAlwaysOnTop(v2rocketLauncher.transform);
flag.rocketLauncher = rocketComp;
GameObject v2maliciousCannon = GameObject.Instantiate(Plugin.maliciousRailcannon, v2WeaponTrans);
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<Railcannon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIdentifier>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponIcon>());
GameObject.DestroyImmediate(v2maliciousCannon.GetComponent<WeaponPos>());
foreach (RailCannonPip pip in UnityUtils.GetComponentsInChildrenRecursively<RailCannonPip>(v2maliciousCannon.transform))
GameObject.DestroyImmediate(pip);
//GameObject.Destroy(v2maliciousCannon.GetComponent<Animator>());
v2maliciousCannon.transform.localScale = new Vector3(0.25f, 0.25f, 0.25f);
v2maliciousCannon.transform.localRotation = Quaternion.Euler(270, 90, 0);
v2maliciousCannon.transform.localPosition = Vector3.zero;
v2maliciousCannon.transform.GetChild(0).localPosition = Vector3.zero;
V2MaliciousCannon cannonComp = v2maliciousCannon.transform.GetChild(0).gameObject.AddComponent<V2MaliciousCannon>();
cannonComp.v2trans = __instance.transform;
RemoveAlwaysOnTop(v2maliciousCannon.transform);
flag.maliciousCannon = cannonComp;
EnemyRevolver rev = UnityUtils.GetComponentInChildrenRecursively<EnemyRevolver>(__instance.weapons[0].transform);
V2CommonRevolverComp revComp;
if (ConfigManager.v2SecondSharpshooterToggle.value)
{
revComp = rev.gameObject.AddComponent<V2CommonRevolverComp>();
revComp.secondPhase = __instance.secondEncounter;
}
__instance.weapons = new GameObject[] { __instance.weapons[0], __instance.weapons[1], __instance.weapons[2], v2rocketLauncher, v2maliciousCannon };
}
}
}
| Ultrapain/Patches/V2Second.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Cerberus.cs",
"retrieved_chunk": " ___eid.health -= ConfigManager.cerberusParryDamage.value;\n MonoSingleton<FistControl>.Instance.currentPunch.Parry(false, ___eid);\n return true;\n }\n }\n class StatueBoss_StopDash_Patch\n {\n public static void Postfix(StatueBoss __instance, ref int ___tackleChance)\n {\n CerberusFlag flag = __instance.GetComponent<CerberusFlag>();",
"score": 0.8712790012359619
},
{
"filename": "Ultrapain/Patches/Panopticon.cs",
"retrieved_chunk": " if (___fleshDroneCooldown < 1f)\n {\n ___fleshDroneCooldown = 1f;\n }\n return false;\n }\n }\n class Panopticon_HomingProjectileAttack\n {\n static void Postfix(FleshPrison __instance, EnemyIdentifier ___eid)",
"score": 0.8327947854995728
},
{
"filename": "Ultrapain/Patches/MinosPrime.cs",
"retrieved_chunk": " flag.explosionAttack = false;\n flag.BigExplosion();\n __instance.Invoke(\"Uppercut\", 0.5f);\n return false;\n }\n }\n class MinosPrime_Death\n {\n static bool Prefix(MinosPrime __instance, Animator ___anim, ref bool ___vibrating)\n {",
"score": 0.8305177092552185
},
{
"filename": "Ultrapain/Patches/Drone.cs",
"retrieved_chunk": " return false;\n }\n Debug.LogError($\"Drone fire mode in impossible state. Current value: {mode} : {(int)mode}\");\n return true;\n }\n }\n class Drone_Update\n {\n static void Postfix(Drone __instance, EnemyIdentifier ___eid, ref float ___attackCooldown, int ___difficulty)\n {",
"score": 0.8240231275558472
},
{
"filename": "Ultrapain/Patches/StreetCleaner.cs",
"retrieved_chunk": " return true;\n }\n static void Postfix(Streetcleaner __instance, ref EnemyIdentifier ___eid)\n {\n if(__instance.IsInvoking(\"StartFire\") && cancelStartFireInvoke)\n {\n __instance.CancelInvoke(\"StartFire\");\n __instance.Invoke(\"StartFire\", 0.1f);\n }\n }",
"score": 0.8221490383148193
}
] | csharp | BossHealthBar __instance, ref EnemyIdentifier ___eid, ref int ___currentHpSlider)
{ |
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using EFT;
using EFT.Interactive;
using EFT.InventoryLogic;
using LootingBots.Patch.Util;
using UnityEngine;
namespace LootingBots.Patch.Components
{
// Degug spheres from DrakiaXYZ Waypoints https://github.com/DrakiaXYZ/SPT-Waypoints/blob/master/Helpers/GameObjectHelper.cs
public class GameObjectHelper
{
public static GameObject DrawSphere(Vector3 position, float size, Color color)
{
var sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.GetComponent<Renderer>().material.color = color;
sphere.GetComponent<Collider>().enabled = false;
sphere.transform.position = new Vector3(position.x, position.y, position.z);
sphere.transform.localScale = new Vector3(size, size, size);
return sphere;
}
}
public class LootingBrain : MonoBehaviour
{
public BotOwner BotOwner;
// Component responsible for adding items to the bot inventory
public | InventoryController InventoryController; |
// Current container that the bot will try to loot
public LootableContainer ActiveContainer;
// Current loose item that the bot will try to loot
public LootItem ActiveItem;
// Current corpse that the bot will try to loot
public BotOwner ActiveCorpse;
// Center of the loot object's collider used to help in navigation
public Vector3 LootObjectCenter;
// Collider.transform.position for the active lootable. Used in LOS checks to make sure bots dont loot through walls
public Vector3 LootObjectPosition;
// Object ids that the bot has looted
public List<string> IgnoredLootIds;
// Object ids that were not able to be reached even though a valid path exists. Is cleared every 2 mins by default
public List<string> NonNavigableLootIds;
public BotStats Stats
{
get { return InventoryController.Stats; }
}
public bool IsBotLooting {
get {
return LootTaskRunning || HasActiveLootable();
}
}
// Boolean showing when the looting coroutine is running
public bool LootTaskRunning = false;
public float DistanceToLoot = 0f;
// Amount of time in seconds to wait after looting successfully
public float WaitAfterLootTimer;
private BotLog _log;
public void Init(BotOwner botOwner)
{
_log = new BotLog(LootingBots.LootLog, botOwner);
BotOwner = botOwner;
InventoryController = new InventoryController(BotOwner, this);
IgnoredLootIds = new List<string> { };
NonNavigableLootIds = new List<string> { };
}
/*
* LootFinder update should only be running if one of the looting settings is enabled and the bot is in an active state
*/
public async Task Update()
{
try
{
WildSpawnType botType = BotOwner.Profile.Info.Settings.Role;
bool isLootFinderEnabled =
LootingBots.ContainerLootingEnabled.Value.IsBotEnabled(botType)
|| LootingBots.LooseItemLootingEnabled.Value.IsBotEnabled(botType)
|| LootingBots.CorpseLootingEnabled.Value.IsBotEnabled(botType);
if (isLootFinderEnabled && BotOwner.BotState == EBotState.Active)
{
if (InventoryController.ShouldSort)
{
// Sort items in tacVest for better space management
await InventoryController.SortTacVest();
}
// Open any nearby door
BotOwner.DoorOpener.Update();
}
}
catch (Exception e)
{
_log.LogError(e);
}
}
/**
* Determines the looting action to take depending on the current Active object in the LootFinder. There can only be one Active object at a time
*/
public void StartLooting()
{
if (ActiveContainer)
{
StartCoroutine(LootContainer());
}
else if (ActiveItem)
{
StartCoroutine(LootItem());
}
else if (ActiveCorpse)
{
StartCoroutine(LootCorpse());
}
}
/**
* Handles looting a corpse found on the map.
*/
public IEnumerator LootCorpse()
{
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
LootTaskRunning = true;
// Initialize corpse inventory controller
Player corpsePlayer = ActiveCorpse.GetPlayer;
Type corpseType = corpsePlayer.GetType();
FieldInfo corpseInventory = corpseType.BaseType.GetField(
"_inventoryController",
BindingFlags.NonPublic
| BindingFlags.Static
| BindingFlags.Public
| BindingFlags.Instance
);
InventoryControllerClass corpseInventoryController = (InventoryControllerClass)
corpseInventory.GetValue(corpsePlayer);
// Get items to loot from the corpse in a priority order based off the slots
EquipmentSlot[] prioritySlots = InventoryController.GetPrioritySlots();
_log.LogWarning($"Trying to loot corpse");
Item[] priorityItems = corpseInventoryController.Inventory.Equipment
.GetSlotsByName(prioritySlots)
.Select(slot => slot.ContainedItem)
.Where(item => item != null && !item.IsUnremovable)
.ToArray();
Task<bool> lootTask = InventoryController.TryAddItemsToBot(priorityItems);
yield return new WaitUntil(() => lootTask.IsCompleted);
InventoryController.UpdateActiveWeapon();
// Only ignore the corpse if looting was not interrupted
CleanupCorpse(lootTask.Result);
OnLootTaskEnd(lootTask.Result);
watch.Stop();
_log.LogDebug(
$"Corpse loot time: {watch.ElapsedMilliseconds / 1000f}s. Net Worth: {Stats.NetLootValue}"
);
}
/**
* Handles looting a container found on the map.
*/
public IEnumerator LootContainer()
{
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
LootTaskRunning = true;
Item item = ActiveContainer.ItemOwner.Items.ToArray()[0];
_log.LogDebug($"Trying to add items from: {item.Name.Localized()}");
bool didOpen = false;
// If a container was closed, open it before looting
if (ActiveContainer.DoorState == EDoorState.Shut)
{
LootUtils.InteractContainer(ActiveContainer, EInteractionType.Open);
didOpen = true;
}
Task delayTask = TransactionController.SimulatePlayerDelay(2000);
yield return new WaitUntil(() => delayTask.IsCompleted);
Task<bool> lootTask = InventoryController.LootNestedItems(item);
yield return new WaitUntil(() => lootTask.IsCompleted);
// Close the container after looting if a container was open, and the bot didnt open it
if (ActiveContainer.DoorState == EDoorState.Open && !didOpen)
{
LootUtils.InteractContainer(ActiveContainer, EInteractionType.Close);
}
InventoryController.UpdateActiveWeapon();
// Only ignore the container if looting was not interrupted
CleanupContainer(lootTask.Result);
OnLootTaskEnd(lootTask.Result);
watch.Stop();
_log.LogDebug(
$"Container loot time: {watch.ElapsedMilliseconds / 1000f}s. Net Worth: {Stats.NetLootValue}"
);
}
/**
* Handles looting a loose item found on the map.
*/
public IEnumerator LootItem()
{
LootTaskRunning = true;
Item item = ActiveItem.ItemOwner.RootItem;
_log.LogDebug($"Trying to pick up loose item: {item.Name.Localized()}");
BotOwner.GetPlayer.UpdateInteractionCast();
Task<bool> lootTask = InventoryController.TryAddItemsToBot(new Item[] { item });
yield return new WaitUntil(() => lootTask.IsCompleted);
BotOwner.GetPlayer.CurrentManagedState.Pickup(false, null);
InventoryController.UpdateActiveWeapon();
// Need to manually cleanup item because the ItemOwner on the original object changes. Only ignore if looting was not interrupted
CleanupItem(lootTask.Result, item);
OnLootTaskEnd(lootTask.Result);
_log.LogDebug($"Net Worth: {Stats.NetLootValue}");
}
public void OnLootTaskEnd(bool lootingSuccessful)
{
UpdateGridStats();
BotOwner.AIData.CalcPower();
LootTaskRunning = false;
if (lootingSuccessful)
{
IncrementLootTimer();
}
}
public void UpdateGridStats()
{
InventoryController.UpdateGridStats();
}
/**
* Check to see if the object being looted has been ignored due to bad navigation, being looted already, or if its in use by another bot
*/
public bool IsLootIgnored(string lootId)
{
bool alreadyTried =
NonNavigableLootIds.Contains(lootId) || IgnoredLootIds.Contains(lootId);
return alreadyTried || ActiveLootCache.IsLootInUse(lootId);
}
/** Check if the item being looted meets the loot value threshold specified in the mod settings. PMC bots use the PMC loot threshold, all other bots such as scavs, bosses, and raiders will use the scav threshold */
public bool IsValuableEnough(Item lootItem)
{
float itemValue = LootingBots.ItemAppraiser.GetItemPrice(lootItem);
return InventoryController.IsValuableEnough(itemValue);
}
/**
* Handles adding non navigable loot to the list of non-navigable ids for use in the ignore logic. Additionaly removes the object from the active loot cache
*/
public void HandleNonNavigableLoot()
{
string lootId =
ActiveContainer?.Id ?? ActiveItem?.ItemOwner.RootItem.Id ?? ActiveCorpse.name;
NonNavigableLootIds.Add(lootId);
Cleanup();
}
/**
* Increment the delay timer used to delay the next loot scan after an object has been looted
*/
public void IncrementLootTimer(float time = -1f)
{
// Increment loot wait timer
float timer = time != -1f ? time : LootingBots.TimeToWaitBetweenLoot.Value;
WaitAfterLootTimer = Time.time + timer;
}
/**
* Returns true if the LootFinder has an ActiveContainer, ActiveItem, or ActiveCorpse defined
*/
public bool HasActiveLootable()
{
return ActiveContainer != null || ActiveItem != null || ActiveCorpse != null;
}
/**
* Adds a loot id to the list of loot items to ignore for a specific bot
*/
public void IgnoreLoot(string id)
{
IgnoredLootIds.Add(id);
}
/**
* Wrapper function to enable transactions to be executed by the InventoryController.
*/
public void EnableTransactions()
{
InventoryController.EnableTransactions();
}
/**
* Wrapper function to disable the execution of transactions by the InventoryController.
*/
public void DisableTransactions()
{
InventoryController.DisableTransactions();
}
/**
* Removes all active lootables from LootFinder and cleans them from the active loot cache
*/
public void Cleanup(bool ignore = true)
{
if (ActiveContainer != null)
{
CleanupContainer(ignore);
}
if (ActiveItem != null)
{
CleanupItem(ignore);
}
if (ActiveCorpse != null)
{
CleanupCorpse(ignore);
}
}
/**
* Removes the ActiveContainer from the LootFinder and ActiveLootCache. Can optionally add the container to the ignore list after cleaning
*/
public void CleanupContainer(bool ignore = true)
{
LootableContainer container = ActiveContainer;
ActiveLootCache.Cleanup(container.Id);
if (ignore)
{
IgnoreLoot(container.Id);
}
ActiveContainer = null;
}
/**
* Removes the ActiveItem from the LootFinder and ActiveLootCache. Can optionally add the item to the ignore list after cleaning
*/
public void CleanupItem(bool ignore = true, Item movedItem = null)
{
Item item = movedItem ?? ActiveItem.ItemOwner?.RootItem;
ActiveLootCache.Cleanup(item.Id);
if (ignore)
{
IgnoreLoot(item.Id);
}
ActiveItem = null;
}
/**
* Removes the ActiveCorpse from the LootFinder and ActiveLootCache. Can optionally add the corpse to the ignore list after cleaning
*/
public void CleanupCorpse(bool ignore = true)
{
BotOwner corpse = ActiveCorpse;
string name = corpse.name;
ActiveLootCache.Cleanup(name);
if (ignore)
{
IgnoreLoot(name);
}
ActiveCorpse = null;
}
}
}
| LootingBots/components/LootingBrain.cs | Skwizzy-SPT-LootingBots-76279a3 | [
{
"filename": "LootingBots/components/InventoryController.cs",
"retrieved_chunk": " Color.white,\n freeSpaceColor\n );\n }\n }\n public class InventoryController\n {\n private readonly BotLog _log;\n private readonly TransactionController _transactionController;\n private readonly BotOwner _botOwner;",
"score": 0.8843979239463806
},
{
"filename": "LootingBots/components/InventoryController.cs",
"retrieved_chunk": " private readonly InventoryControllerClass _botInventoryController;\n private readonly LootingBrain _lootingBrain;\n private readonly ItemAppraiser _itemAppraiser;\n private readonly bool _isBoss;\n public BotStats Stats = new BotStats();\n private static readonly GearValue GearValue = new GearValue();\n // Represents the highest equipped armor class of the bot either from the armor vest or tac vest\n public int CurrentBodyArmorClass = 0;\n // Represents the value in roubles of the current item\n public float CurrentItemPrice = 0f;",
"score": 0.8489153385162354
},
{
"filename": "LootingBots/utils/LootUtils.cs",
"retrieved_chunk": " public static LayerMask LowPolyMask = LayerMask.GetMask(new string[] { \"LowPolyCollider\" });\n public static LayerMask LootMask = LayerMask.GetMask(\n new string[] { \"Interactive\", \"Loot\", \"Deadbody\" }\n );\n /* Simple check to see if the current bot is a Boss type */\n public static bool IsBoss(BotOwner botOwner)\n {\n return botOwner.Boss != null;\n }\n /** Calculate the size of a container */",
"score": 0.8432590365409851
},
{
"filename": "LootingBots/utils/LootCache.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nnamespace LootingBots.Patch.Util\n{\n // Cached used to keep track of what lootable are currently being targeted by a bot so that multiple bots\n // dont try and path to the same lootable\n public static class ActiveLootCache\n {\n public static Dictionary<string, string> ActiveLoot = new Dictionary<string, string>();\n public static void Reset()",
"score": 0.841727614402771
},
{
"filename": "LootingBots/components/TransactionController.cs",
"retrieved_chunk": " OnComplete = onComplete;\n }\n }\n public class MoveAction\n {\n public Item ToMove;\n public ItemAddress Place;\n public ActionCallback Callback;\n public ActionCallback OnComplete;\n public MoveAction(",
"score": 0.8404642343521118
}
] | csharp | InventoryController InventoryController; |
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Ultrapain.Patches
{
public static class V2Utils
{
public static | Transform GetClosestGrenade()
{ |
Transform closestTransform = null;
float closestDistance = 1000000;
foreach(Grenade g in GrenadeList.Instance.grenadeList)
{
float dist = Vector3.Distance(g.transform.position, PlayerTracker.Instance.GetTarget().position);
if(dist < closestDistance)
{
closestTransform = g.transform;
closestDistance = dist;
}
}
foreach (Cannonball c in GrenadeList.Instance.cannonballList)
{
float dist = Vector3.Distance(c.transform.position, PlayerTracker.Instance.GetTarget().position);
if (dist < closestDistance)
{
closestTransform = c.transform;
closestDistance = dist;
}
}
return closestTransform;
}
public static Vector3 GetDirectionAwayFromTarget(Vector3 center, Vector3 target)
{
// Calculate the direction vector from the center to the target
Vector3 direction = target - center;
// Set the Y component of the direction vector to 0
direction.y = 0;
// Normalize the direction vector
direction.Normalize();
// Reverse the direction vector to face away from the target
direction = -direction;
return direction;
}
}
class V2CommonExplosion
{
static void Postfix(Explosion __instance)
{
if (__instance.sourceWeapon == null)
return;
V2MaliciousCannon malCanComp = __instance.sourceWeapon.GetComponent<V2MaliciousCannon>();
if(malCanComp != null)
{
Debug.Log("Grenade explosion triggered by V2 malicious cannon");
__instance.toIgnore.Add(EnemyType.V2);
__instance.toIgnore.Add(EnemyType.V2Second);
return;
}
EnemyRevolver revComp = __instance.sourceWeapon.GetComponentInChildren<EnemyRevolver>();
if(revComp != null)
{
Debug.Log("Grenade explosion triggered by V2 revolver");
__instance.toIgnore.Add(EnemyType.V2);
__instance.toIgnore.Add(EnemyType.V2Second);
return;
}
}
}
// SHARPSHOOTER
class V2CommonRevolverComp : MonoBehaviour
{
public bool secondPhase = false;
public bool shootingForSharpshooter = false;
}
class V2CommonRevolverPrepareAltFire
{
static bool Prefix(EnemyRevolver __instance, GameObject ___altCharge)
{
if(__instance.TryGetComponent<V2CommonRevolverComp>(out V2CommonRevolverComp comp))
{
if ((comp.secondPhase && !ConfigManager.v2SecondSharpshooterToggle.value)
|| (!comp.secondPhase && !ConfigManager.v2FirstSharpshooterToggle.value))
return true;
bool sharp = UnityEngine.Random.Range(0f, 100f) <= (comp.secondPhase ? ConfigManager.v2SecondSharpshooterChance.value : ConfigManager.v2FirstSharpshooterChance.value);
Transform quad = ___altCharge.transform.Find("MuzzleFlash/Quad");
MeshRenderer quadRenderer = quad.gameObject.GetComponent<MeshRenderer>();
quadRenderer.material.color = sharp ? new Color(1f, 0.1f, 0f) : new Color(1f, 1f, 1f);
comp.shootingForSharpshooter = sharp;
}
return true;
}
}
class V2CommonRevolverBulletSharp : MonoBehaviour
{
public int reflectionCount = 2;
public float autoAimAngle = 30f;
public Projectile proj;
public float speed = 350f;
public bool hasTargetPoint = false;
public Vector3 shootPoint;
public Vector3 targetPoint;
public RaycastHit targetHit;
public bool alreadyHitPlayer = false;
public bool alreadyReflected = false;
private void Awake()
{
proj = GetComponent<Projectile>();
proj.speed = 0;
GetComponent<Rigidbody>().isKinematic = true;
}
private void Update()
{
if (!hasTargetPoint)
transform.position += transform.forward * speed;
else
{
if (transform.position != targetPoint)
{
transform.position = Vector3.MoveTowards(transform.position, targetPoint, Time.deltaTime * speed);
if (transform.position == targetPoint)
proj.SendMessage("Collided", targetHit.collider);
}
else
proj.SendMessage("Collided", targetHit.collider);
}
}
}
class V2CommonRevolverBullet
{
static bool Prefix(Projectile __instance, Collider __0)
{
V2CommonRevolverBulletSharp comp = __instance.GetComponent<V2CommonRevolverBulletSharp>();
if (comp == null)
return true;
if ((__0.gameObject.tag == "Head" || __0.gameObject.tag == "Body" || __0.gameObject.tag == "Limb" || __0.gameObject.tag == "EndLimb") && __0.gameObject.tag != "Armor")
{
EnemyIdentifierIdentifier eii = __instance.GetComponent<EnemyIdentifierIdentifier>();
if (eii != null)
{
eii.eid.hitter = "enemy";
eii.eid.DeliverDamage(__0.gameObject, __instance.transform.forward * 100f, __instance.transform.position, comp.proj.damage / 10f, false, 0f, null, false);
return false;
}
}
if (comp.alreadyReflected)
return false;
bool isPlayer = __0.gameObject.tag == "Player";
if (isPlayer)
{
if (comp.alreadyHitPlayer)
return false;
NewMovement.Instance.GetHurt(Mathf.RoundToInt(comp.proj.damage), true, 1f, false, false);
comp.alreadyHitPlayer = true;
return false;
}
if (!comp.hasTargetPoint || comp.transform.position != comp.targetPoint)
return false;
if(comp.reflectionCount <= 0)
{
comp.alreadyReflected = true;
return true;
}
// REFLECTION
LayerMask envMask = new LayerMask() { value = 1 << 8 | 1 << 24 };
GameObject reflectedBullet = GameObject.Instantiate(__instance.gameObject, comp.targetPoint, __instance.transform.rotation);
V2CommonRevolverBulletSharp reflectComp = reflectedBullet.GetComponent<V2CommonRevolverBulletSharp>();
reflectComp.reflectionCount -= 1;
reflectComp.shootPoint = reflectComp.transform.position;
reflectComp.alreadyReflected = false;
reflectComp.alreadyHitPlayer = false;
reflectedBullet.transform.forward = Vector3.Reflect(comp.transform.forward, comp.targetHit.normal).normalized;
Vector3 playerPos = NewMovement.Instance.transform.position;
Vector3 playerVectorFromBullet = playerPos - reflectedBullet.transform.position;
float angle = Vector3.Angle(playerVectorFromBullet, reflectedBullet.transform.forward);
if (angle <= ConfigManager.v2FirstSharpshooterAutoaimAngle.value)
{
Quaternion lastRotation = reflectedBullet.transform.rotation;
reflectedBullet.transform.LookAt(NewMovement.Instance.playerCollider.bounds.center);
RaycastHit[] hits = Physics.RaycastAll(reflectedBullet.transform.position, reflectedBullet.transform.forward, Vector3.Distance(reflectedBullet.transform.position, playerPos));
bool hitEnv = false;
foreach (RaycastHit rayHit in hits)
{
if (rayHit.transform.gameObject.layer == 8 || rayHit.transform.gameObject.layer == 24)
{
hitEnv = true;
break;
}
}
if (hitEnv)
{
reflectedBullet.transform.rotation = lastRotation;
}
}
if(Physics.Raycast(reflectedBullet.transform.position, reflectedBullet.transform.forward, out RaycastHit hit, float.PositiveInfinity, envMask))
{
reflectComp.targetPoint = hit.point;
reflectComp.targetHit = hit;
reflectComp.hasTargetPoint = true;
}
else
{
reflectComp.hasTargetPoint = false;
}
comp.alreadyReflected = true;
GameObject.Instantiate(Plugin.ricochetSfx, reflectedBullet.transform.position, Quaternion.identity);
return true;
}
}
class V2CommonRevolverAltShoot
{
static bool Prefix(EnemyRevolver __instance, EnemyIdentifier ___eid)
{
if (__instance.TryGetComponent<V2CommonRevolverComp>(out V2CommonRevolverComp comp) && comp.shootingForSharpshooter)
{
__instance.CancelAltCharge();
Vector3 position = __instance.shootPoint.position;
if (Vector3.Distance(__instance.transform.position, ___eid.transform.position) > Vector3.Distance(MonoSingleton<NewMovement>.Instance.transform.position, ___eid.transform.position))
{
position = new Vector3(___eid.transform.position.x, __instance.transform.position.y, ___eid.transform.position.z);
}
GameObject bullet = GameObject.Instantiate(__instance.altBullet, position, __instance.shootPoint.rotation);
V2CommonRevolverBulletSharp bulletComp = bullet.AddComponent<V2CommonRevolverBulletSharp>();
bulletComp.autoAimAngle = comp.secondPhase ? ConfigManager.v2SecondSharpshooterAutoaimAngle.value : ConfigManager.v2FirstSharpshooterAutoaimAngle.value;
bulletComp.reflectionCount = comp.secondPhase ? ConfigManager.v2SecondSharpshooterReflections.value : ConfigManager.v2FirstSharpshooterReflections.value;
bulletComp.speed *= comp.secondPhase ? ConfigManager.v2SecondSharpshooterSpeed.value : ConfigManager.v2FirstSharpshooterSpeed.value;
TrailRenderer rend = UnityUtils.GetComponentInChildrenRecursively<TrailRenderer>(bullet.transform);
rend.endColor = rend.startColor = new Color(1, 0, 0);
Projectile component = bullet.GetComponent<Projectile>();
if (component)
{
component.safeEnemyType = __instance.safeEnemyType;
component.damage *= comp.secondPhase ? ConfigManager.v2SecondSharpshooterDamage.value : ConfigManager.v2FirstSharpshooterDamage.value;
}
LayerMask envMask = new LayerMask() { value = 1 << 8 | 1 << 24 };
float v2Height = -1;
RaycastHit v2Ground;
if (!Physics.Raycast(position, Vector3.down, out v2Ground, float.PositiveInfinity, envMask))
v2Height = v2Ground.distance;
float playerHeight = -1;
RaycastHit playerGround;
if (!Physics.Raycast(NewMovement.Instance.transform.position, Vector3.down, out playerGround, float.PositiveInfinity, envMask))
playerHeight = playerGround.distance;
if (v2Height != -1 && playerHeight != -1)
{
Vector3 playerGroundFromV2 = playerGround.point - v2Ground.point;
float distance = Vector3.Distance(playerGround.point, v2Ground.point);
float k = playerHeight / v2Height;
float d1 = (distance * k) / (1 + k);
Vector3 lookPoint = v2Ground.point + (playerGroundFromV2 / distance) * d1;
bullet.transform.LookAt(lookPoint);
}
else
{
Vector3 mid = ___eid.transform.position + (NewMovement.Instance.transform.position - ___eid.transform.position) * 0.5f;
if (Physics.Raycast(mid, Vector3.down, out RaycastHit hit, 1000f, new LayerMask() { value = 1 << 8 | 1 << 24 }))
{
bullet.transform.LookAt(hit.point);
}
else
{
bullet.transform.LookAt(NewMovement.Instance.playerCollider.bounds.center);
}
}
GameObject.Instantiate(__instance.muzzleFlashAlt, __instance.shootPoint.position, __instance.shootPoint.rotation);
if (Physics.Raycast(bullet.transform.position, bullet.transform.forward, out RaycastHit predictedHit, float.PositiveInfinity, envMask))
{
bulletComp.targetPoint = predictedHit.point;
bulletComp.targetHit = predictedHit;
bulletComp.hasTargetPoint = true;
}
else
{
bulletComp.hasTargetPoint = false;
}
comp.shootingForSharpshooter = false;
return false;
}
return true;
}
}
}
| Ultrapain/Patches/V2Common.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Idol.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Text;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class Idol_Death_Patch\n {\n static void Postfix(Idol __instance)\n {",
"score": 0.8864582180976868
},
{
"filename": "Ultrapain/Patches/CommonComponents.cs",
"retrieved_chunk": "using HarmonyLib;\nusing System;\nusing System.Collections.Generic;\nusing System.Text;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n /*public class ObjectActivator : MonoBehaviour\n {\n public int originalInstanceID = 0;",
"score": 0.8782122135162354
},
{
"filename": "Ultrapain/Patches/GabrielSecond.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Reflection;\nusing System.Text;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class GabrielSecondFlag : MonoBehaviour\n {\n public int maxChaos = 7;",
"score": 0.8661545515060425
},
{
"filename": "Ultrapain/Patches/MaliciousFace.cs",
"retrieved_chunk": "using HarmonyLib;\nusing System;\nusing System.ComponentModel;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class MaliciousFaceFlag : MonoBehaviour\n {\n public bool charging = false;\n }",
"score": 0.8661096692085266
},
{
"filename": "Ultrapain/Patches/EnrageEffect.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class EnrageEffect_Start\n {\n static void Postfix(EnrageEffect __instance)",
"score": 0.8631429672241211
}
] | csharp | Transform GetClosestGrenade()
{ |
using System;
using Sandland.SceneTool.Editor.Common.Data;
using Sandland.SceneTool.Editor.Common.Utils;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.UIElements;
namespace Sandland.SceneTool.Editor.Views
{
internal class SceneItemView : VisualElement, IDisposable
{
public const float FixedHeight = 100;
private readonly Image _iconImage;
private readonly | FavoritesButton _favoritesButton; |
private readonly Label _button;
private readonly Label _typeLabel;
private readonly VisualElement _textWrapper;
private readonly Clickable _clickManipulator;
private AssetFileInfo _sceneInfo;
public SceneItemView()
{
var visualTree = AssetDatabaseUtils.FindAndLoadVisualTreeAsset("SceneItemView");
visualTree.CloneTree(this);
_iconImage = this.Q<Image>("scene-icon");
_button = this.Q<Label>("scene-button");
_favoritesButton = this.Q<FavoritesButton>("favorites-button");
_typeLabel = this.Q<Label>("scene-type-label");
_textWrapper = this.Q<VisualElement>("scene-text-wrapper");
_clickManipulator = new Clickable(OnOpenSceneButtonClicked);
_textWrapper.AddManipulator(_clickManipulator);
RegisterCallback<DetachFromPanelEvent>(OnDetachFromPanel);
_iconImage.AddManipulator(new Clickable(OnIconClick));
}
private void OnIconClick()
{
Selection.activeObject = AssetDatabase.LoadAssetAtPath<SceneAsset>(_sceneInfo.Path);
}
public void Init(SceneInfo info)
{
_sceneInfo = info;
_button.text = _sceneInfo.Name;
_favoritesButton.Init(_sceneInfo);
_typeLabel.text = info.ImportType.ToDescription();
// TODO: Support dynamic themes
_iconImage.image = Icons.GetSceneIcon(true);
ResetInlineStyles();
}
private void ResetInlineStyles()
{
// ListView sets inline attributes that we want to control from UCSS
style.height = StyleKeyword.Null;
style.flexGrow = StyleKeyword.Null;
style.flexShrink = StyleKeyword.Null;
style.marginBottom = StyleKeyword.Null;
style.marginTop = StyleKeyword.Null;
style.paddingBottom = StyleKeyword.Null;
}
private void OnOpenSceneButtonClicked()
{
EditorSceneManager.OpenScene(_sceneInfo.Path);
}
private void OnDetachFromPanel(DetachFromPanelEvent evt)
{
Dispose();
}
public void Dispose()
{
UnregisterCallback<DetachFromPanelEvent>(OnDetachFromPanel);
}
}
} | Assets/SceneTools/Editor/Views/SceneSelectorWindow/SceneListItem/SceneItemView.cs | migus88-Sandland.SceneTools-64e9f8c | [
{
"filename": "Assets/SceneTools/Editor/Common/Utils/Icons.cs",
"retrieved_chunk": "using System;\nusing Sandland.SceneTool.Editor.Common.Data;\nusing UnityEditor;\nusing UnityEngine;\nnamespace Sandland.SceneTool.Editor.Common.Utils\n{\n internal static class Icons\n {\n private const string IconsRoot = \"Sandland/Images/\";\n public static Texture2D BrightSceneToolIcon => _brightSceneToolIcon ??=",
"score": 0.8632623553276062
},
{
"filename": "Assets/SceneTools/Editor/Views/SceneToolsSetupWindow/ThemeDisplay/ThemeDisplay.cs",
"retrieved_chunk": "using System;\nusing Sandland.SceneTool.Editor.Common.Data;\nusing Sandland.SceneTool.Editor.Common.Utils;\nusing UnityEditor;\nusing UnityEngine.UIElements;\nnamespace Sandland.SceneTool.Editor.Views\n{\n internal class ThemeDisplay : RadioButton, IDisposable\n {\n public event Action<AssetFileInfo> Selected;",
"score": 0.8298244476318359
},
{
"filename": "Assets/SceneTools/Editor/Listeners/SceneClassGenerationListener.cs",
"retrieved_chunk": "using UnityEditor.AddressableAssets.Settings;\n#endif\nnamespace Sandland.SceneTool.Editor.Listeners\n{\n internal static class SceneClassGenerationListener\n {\n [InitializeOnLoadMethod]\n private static void Initialize()\n {\n EditorBuildSettings.sceneListChanged += GenerateScenesClass;",
"score": 0.826180100440979
},
{
"filename": "Assets/SceneTools/Editor/Views/Base/SceneToolsWindowBase.cs",
"retrieved_chunk": "using Sandland.SceneTool.Editor.Common.Utils;\nusing Sandland.SceneTool.Editor.Services;\nusing UnityEditor;\nusing UnityEngine;\nusing UnityEngine.UIElements;\nnamespace Sandland.SceneTool.Editor.Views.Base\n{\n internal abstract class SceneToolsWindowBase : EditorWindow\n {\n private const string GlobalStyleSheetName = \"SceneToolsMain\";",
"score": 0.8240071535110474
},
{
"filename": "Assets/SceneTools/Editor/Common/Utils/MenuItems.cs",
"retrieved_chunk": "namespace Sandland.SceneTool.Editor.Common.Utils\n{\n internal static class MenuItems\n {\n public static class Tools\n {\n public const string Root = \"Tools/Sandland Games/\";\n public const string Actions = Root + \"Actions/\";\n }\n public static class Creation",
"score": 0.8194135427474976
}
] | csharp | FavoritesButton _favoritesButton; |
#nullable enable
using System;
using System.Threading;
using Cysharp.Threading.Tasks;
using Mochineko.Relent.Result;
namespace Mochineko.RelentStateMachine
{
public sealed class FiniteStateMachine<TEvent, TContext>
: IFiniteStateMachine<TEvent, TContext>
{
private readonly ITransitionMap<TEvent, TContext> transitionMap;
public TContext Context { get; }
private IState<TEvent, TContext> currentState;
public bool IsCurrentState<TState>()
where TState : IState<TEvent, TContext>
=> currentState is TState;
private readonly SemaphoreSlim semaphore = new(
initialCount: 1,
maxCount: 1);
private readonly TimeSpan semaphoreTimeout;
private const float DefaultSemaphoreTimeoutSeconds = 30f;
public static async UniTask<FiniteStateMachine<TEvent, TContext>> CreateAsync(
| ITransitionMap<TEvent, TContext> transitionMap,
TContext context,
CancellationToken cancellationToken,
TimeSpan? semaphoreTimeout = null)
{ |
var instance = new FiniteStateMachine<TEvent, TContext>(
transitionMap,
context,
semaphoreTimeout);
var enterResult = await instance.currentState
.EnterAsync(context, cancellationToken);
switch (enterResult)
{
case NoEventRequest<TEvent>:
return instance;;
case SomeEventRequest<TEvent> eventRequest:
var sendEventResult = await instance
.SendEventAsync(eventRequest.Event, cancellationToken);
return instance;;
default:
throw new ArgumentOutOfRangeException(nameof(enterResult));
}
}
private FiniteStateMachine(
ITransitionMap<TEvent, TContext> transitionMap,
TContext context,
TimeSpan? semaphoreTimeout = null)
{
this.transitionMap = transitionMap;
this.Context = context;
this.currentState = this.transitionMap.InitialState;
this.semaphoreTimeout =
semaphoreTimeout
?? TimeSpan.FromSeconds(DefaultSemaphoreTimeoutSeconds);
}
public void Dispose()
{
transitionMap.Dispose();
semaphore.Dispose();
}
public async UniTask<IResult> SendEventAsync(
TEvent @event,
CancellationToken cancellationToken)
{
// Check transition.
IState<TEvent, TContext> nextState;
var transitionCheckResult = transitionMap.AllowedToTransit(currentState, @event);
switch (transitionCheckResult)
{
case ISuccessResult<IState<TEvent, TContext>> transitionSuccess:
nextState = transitionSuccess.Result;
break;
case IFailureResult<IState<TEvent, TContext>> transitionFailure:
return Results.Fail(
$"Failed to transit state because of {transitionFailure.Message}.");
default:
throw new ResultPatternMatchException(nameof(transitionCheckResult));
}
var transitResult = await TransitAsync(nextState, cancellationToken);
switch (transitResult)
{
case ISuccessResult<IEventRequest<TEvent>> successResult
when successResult.Result is SomeEventRequest<TEvent> eventRequest:
// NOTE: Recursive calling.
return await SendEventAsync(eventRequest.Event, cancellationToken);
case ISuccessResult<IEventRequest<TEvent>> successResult:
return Results.Succeed();
case IFailureResult<IEventRequest<TEvent>> failureResult:
return Results.Fail(
$"Failed to transit state from {currentState.GetType()} to {nextState.GetType()} because of {failureResult.Message}.");
default:
throw new ResultPatternMatchException(nameof(transitResult));
}
}
private async UniTask<IResult<IEventRequest<TEvent>>> TransitAsync(
IState<TEvent, TContext> nextState,
CancellationToken cancellationToken)
{
// Make state thread-safe.
try
{
await semaphore.WaitAsync(semaphoreTimeout, cancellationToken);
}
catch (OperationCanceledException exception)
{
semaphore.Release();
return StateResults.Fail<TEvent>(
$"Cancelled to wait semaphore because of {exception}.");
}
try
{
// Exit current state.
await currentState.ExitAsync(Context, cancellationToken);
// Enter next state.
var enterResult = await nextState.EnterAsync(Context, cancellationToken);
currentState = nextState;
return Results.Succeed(enterResult);
}
catch (OperationCanceledException exception)
{
return StateResults.Fail<TEvent>(
$"Cancelled to transit state because of {exception}.");
}
finally
{
semaphore.Release();
}
}
public async UniTask UpdateAsync(CancellationToken cancellationToken)
{
var updateResult = await currentState.UpdateAsync(Context, cancellationToken);
switch (updateResult)
{
case NoEventRequest<TEvent>:
break;
case SomeEventRequest<TEvent> eventRequest:
await SendEventAsync(eventRequest.Event, cancellationToken);
return;
default:
throw new ArgumentOutOfRangeException(nameof(updateResult));
}
}
}
} | Assets/Mochineko/RelentStateMachine/FiniteStateMachine.cs | mochi-neko-RelentStateMachine-64762eb | [
{
"filename": "Assets/Mochineko/RelentStateMachine/StackStateMachine.cs",
"retrieved_chunk": " private readonly TimeSpan semaphoreTimeout;\n private const float DefaultSemaphoreTimeoutSeconds = 30f;\n public static async UniTask<StackStateMachine<TContext>> CreateAsync(\n IStateStore<TContext> stateStore,\n TContext context,\n CancellationToken cancellationToken,\n TimeSpan? semaphoreTimeout = null)\n {\n var instance = new StackStateMachine<TContext>(\n stateStore,",
"score": 0.9435403943061829
},
{
"filename": "Assets/Mochineko/RelentStateMachine/StackStateMachine.cs",
"retrieved_chunk": " context,\n semaphoreTimeout);\n await instance.stack.Peek()\n .EnterAsync(context, cancellationToken);\n return instance;\n }\n private StackStateMachine(\n IStateStore<TContext> stateStore,\n TContext context,\n TimeSpan? semaphoreTimeout = null)",
"score": 0.8988372087478638
},
{
"filename": "Assets/Mochineko/RelentStateMachine.Tests/Phase3State.cs",
"retrieved_chunk": " CancellationToken cancellationToken)\n {\n await UniTask.Delay(\n TimeSpan.FromSeconds(0.01f),\n cancellationToken: cancellationToken);\n return EventRequests<MockContinueEvent>.None();\n }\n public async UniTask ExitAsync(\n MockContinueContext context,\n CancellationToken cancellationToken)",
"score": 0.8520709276199341
},
{
"filename": "Assets/Mochineko/RelentStateMachine.Tests/Phase1State.cs",
"retrieved_chunk": " CancellationToken cancellationToken)\n {\n await UniTask.Delay(\n TimeSpan.FromSeconds(0.01f),\n cancellationToken: cancellationToken);\n return EventRequests<MockContinueEvent>.None();\n }\n public async UniTask ExitAsync(\n MockContinueContext context,\n CancellationToken cancellationToken)",
"score": 0.8519824147224426
},
{
"filename": "Assets/Mochineko/RelentStateMachine.Tests/Phase2State.cs",
"retrieved_chunk": " CancellationToken cancellationToken)\n {\n await UniTask.Delay(\n TimeSpan.FromSeconds(0.01f),\n cancellationToken: cancellationToken);\n return EventRequests<MockContinueEvent>.None();\n }\n public async UniTask ExitAsync(\n MockContinueContext context,\n CancellationToken cancellationToken)",
"score": 0.8511846661567688
}
] | csharp | ITransitionMap<TEvent, TContext> transitionMap,
TContext context,
CancellationToken cancellationToken,
TimeSpan? semaphoreTimeout = null)
{ |
using FayElf.Plugins.WeChat.OfficialAccount.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XiaoFeng;
using XiaoFeng.Http;
/****************************************************************
* Copyright © (2022) www.fayelf.com All Rights Reserved. *
* Author : jacky *
* QQ : 7092734 *
* Email : [email protected] *
* Site : www.fayelf.com *
* Create Time : 2022-03-18 08:56:16 *
* Version : v 1.0.0 *
* CLR Version : 4.0.30319.42000 *
*****************************************************************/
namespace FayElf.Plugins.WeChat.OfficialAccount
{
/// <summary>
/// 模板消息操作类
/// </summary>
public class Template
{
#region 构造器
/// <summary>
/// 无参构造器
/// </summary>
public Template()
{
this.Config = Config.Current;
}
/// <summary>
/// 设置配置
/// </summary>
/// <param name="config">配置</param>
public Template(Config config)
{
this.Config = config;
}
#endregion
#region 属性
/// <summary>
/// 配置
/// </summary>
public Config Config { get; set; }
#endregion
#region 方法
#region 设置所属行业
/// <summary>
/// 设置所属行业
/// </summary>
/// <param name="industry1">公众号模板消息所属行业编号</param>
/// <param name="industry2">公众号模板消息所属行业编号</param>
/// <returns></returns>
public BaseResult SetIndustry(Industry industry1,Industry industry2)
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method= HttpMethod.Post,
Address=$"https://api.weixin.qq.com/cgi-bin/template/api_set_industry?access_token={token.AccessToken}",
BodyData = $@"{{""industry_id1"":""{(int)industry1}"",""industry_id2"":""{(int)industry2}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<BaseResult>();
}
else
{
return new BaseResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获取设置的行业信息
/*
* {
"primary_industry":{"first_class":"运输与仓储","second_class":"快递"},
"secondary_industry":{"first_class":"IT科技","second_class":"互联网|电子商务"}
}
*/
/// <summary>
/// 获取设置的行业信息
/// </summary>
/// <returns></returns>
public IndustryModelResult GetIndustry()
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Get,
Address = $"https://api.weixin.qq.com/cgi-bin/template/get_industry?access_token={token.AccessToken}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryModelResult>();
}
else
{
return new IndustryModelResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获得模板ID
/// <summary>
/// 获得模板ID
/// </summary>
/// <param name="templateId">模板库中模板的编号，有“TM**”和“OPENTMTM**”等形式</param>
/// <returns></returns>
public IndustryTemplateResult AddTemplate(string templateId)
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/template/api_add_template?access_token={token.AccessToken}",
BodyData = $@"{{""template_id_short"":""{templateId}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateResult>();
}
else
{
return new IndustryTemplateResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获取模板列表
/// <summary>
/// 获取模板列表
/// </summary>
/// <returns></returns>
public IndustryTemplateListResult GetAllPrivateTemplate()
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Get,
Address = $"https://api.weixin.qq.com/cgi-bin/template/api_add_template?access_token={token.AccessToken}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateListResult>();
}
else
{
return new IndustryTemplateListResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 删除模板
/// <summary>
/// 删除模板
/// </summary>
/// <param name="templateId">公众帐号下模板消息ID</param>
/// <returns></returns>
public Boolean DeletePrivateTemplate(string templateId)
{
var config = this.Config.GetConfig(WeChatType.Applets);
var result = Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/template/del_private_template?access_token={token.AccessToken}",
BodyData = $@"{{""template_id"":""{templateId}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<BaseResult>();
}
else
{
return new BaseResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
return result.ErrCode == 0;
}
#endregion
#region 发送模板消息
/// <summary>
/// 发送模板消息
/// </summary>
/// <param name="data">发送数据</param>
/// <returns></returns>
public | IndustryTemplateSendDataResult Send(IndustryTemplateSendData data)
{ |
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/message/template/send?access_token={token.AccessToken}",
BodyData = data.ToJson()
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateSendDataResult>();
}
else
{
return new IndustryTemplateSendDataResult
{
ErrCode = 500,
ErrMsg = "请求出错."
};
}
});
}
#endregion
#endregion
}
} | OfficialAccount/Template.cs | zhuovi-FayElf.Plugins.WeChat-5725d1e | [
{
"filename": "OfficialAccount/Subscribe.cs",
"retrieved_chunk": " #endregion\n #region 删除模板\n /// <summary>\n /// 删除模板\n /// </summary>\n /// <param name=\"priTmplId\">要删除的模板id</param>\n /// <returns></returns>\n public BaseResult DeleteTemplate(string priTmplId)\n {\n var config = this.Config.GetConfig(WeChatType.Applets);",
"score": 0.8472861051559448
},
{
"filename": "OfficialAccount/Receive.cs",
"retrieved_chunk": " /// 输出文本消息\n /// </summary>\n /// <param name=\"fromUserName\">发送方帐号</param>\n /// <param name=\"toUserName\">接收方帐号</param>\n /// <param name=\"content\">回复内容</param>\n /// <returns></returns>\n public string ReplayText(string fromUserName, string toUserName, string content) => this.ReplayContent(MessageType.text, fromUserName, toUserName, () => $\"<Content><![CDATA[{content}]]></Content>\");\n #endregion\n #region 回复图片\n /// <summary>",
"score": 0.80516517162323
},
{
"filename": "OfficialAccount/Model/IndustryTemplateSendData.cs",
"retrieved_chunk": " [Description(\"模板数据\"), JsonElement(\"data\")] \n public Dictionary<string, ValueColor> Data { get; set; }\n #endregion\n #region 方法\n #endregion\n }\n /// <summary>\n /// 发送数据返回结果\n /// </summary>\n public class IndustryTemplateSendDataResult : BaseResult",
"score": 0.7978384494781494
},
{
"filename": "OfficialAccount/Subscribe.cs",
"retrieved_chunk": " }\n });\n }\n #endregion\n #region 获取公众号类目\n /// <summary>\n /// 获取公众号类目\n /// </summary>\n /// <returns></returns>\n public TemplateCategoryResult GetCategory()",
"score": 0.7970502376556396
},
{
"filename": "Applets/Applets.cs",
"retrieved_chunk": " #endregion\n #region 获取用户encryptKey\n /// <summary>\n /// 获取用户encryptKey\n /// </summary>\n /// <param name=\"session\">Session数据</param>\n /// <returns></returns>\n public UserEncryptKeyData GetUserEncryptKey(JsCodeSessionData session)\n {\n var config = this.Config.GetConfig(WeChatType.Applets);",
"score": 0.7907518148422241
}
] | csharp | IndustryTemplateSendDataResult Send(IndustryTemplateSendData data)
{ |
using BepInEx;
using BepInEx.Configuration;
using Comfort.Common;
using EFT;
using LootingBots.Patch.Components;
using LootingBots.Patch.Util;
using LootingBots.Patch;
using LootingBots.Brain;
using DrakiaXYZ.BigBrain.Brains;
using System.Collections.Generic;
using HandbookClass = GClass2775;
namespace LootingBots
{
[BepInPlugin(MOD_GUID, MOD_NAME, MOD_VERSION)]
[BepInDependency("xyz.drakia.bigbrain", "0.1.4")]
[BepInProcess("EscapeFromTarkov.exe")]
public class LootingBots : BaseUnityPlugin
{
private const string MOD_GUID = "me.skwizzy.lootingbots";
private const string MOD_NAME = "LootingBots";
private const string MOD_VERSION = "1.1.2";
public const | BotType SettingsDefaults = BotType.Scav | BotType.Pmc | BotType.Raider; |
// Loot Finder Settings
public static ConfigEntry<BotType> CorpseLootingEnabled;
public static ConfigEntry<BotType> ContainerLootingEnabled;
public static ConfigEntry<BotType> LooseItemLootingEnabled;
public static ConfigEntry<float> TimeToWaitBetweenLoot;
public static ConfigEntry<float> DetectItemDistance;
public static ConfigEntry<float> DetectContainerDistance;
public static ConfigEntry<float> DetectCorpseDistance;
public static ConfigEntry<bool> DebugLootNavigation;
public static ConfigEntry<LogLevel> LootingLogLevels;
public static Log LootLog;
// Loot Settings
public static ConfigEntry<bool> UseMarketPrices;
public static ConfigEntry<bool> ValueFromMods;
public static ConfigEntry<bool> CanStripAttachments;
public static ConfigEntry<float> PMCLootThreshold;
public static ConfigEntry<float> ScavLootThreshold;
public static ConfigEntry<EquipmentType> PMCGearToEquip;
public static ConfigEntry<EquipmentType> PMCGearToPickup;
public static ConfigEntry<EquipmentType> ScavGearToEquip;
public static ConfigEntry<EquipmentType> ScavGearToPickup;
public static ConfigEntry<LogLevel> ItemAppraiserLogLevels;
public static Log ItemAppraiserLog;
public static ItemAppraiser ItemAppraiser = new ItemAppraiser();
public void LootFinderSettings()
{
CorpseLootingEnabled = Config.Bind(
"Loot Finder",
"Enable corpse looting",
SettingsDefaults,
new ConfigDescription(
"Enables corpse looting for the selected bot types",
null,
new ConfigurationManagerAttributes { Order = 10 }
)
);
DetectCorpseDistance = Config.Bind(
"Loot Finder",
"Detect corpse distance",
75f,
new ConfigDescription(
"Distance (in meters) a bot is able to detect a corpse",
null,
new ConfigurationManagerAttributes { Order = 9 }
)
);
ContainerLootingEnabled = Config.Bind(
"Loot Finder",
"Enable container looting",
SettingsDefaults,
new ConfigDescription(
"Enables container looting for the selected bot types",
null,
new ConfigurationManagerAttributes { Order = 8 }
)
);
DetectContainerDistance = Config.Bind(
"Loot Finder",
"Detect container distance",
75f,
new ConfigDescription(
"Distance (in meters) a bot is able to detect a container",
null,
new ConfigurationManagerAttributes { Order = 7 }
)
);
LooseItemLootingEnabled = Config.Bind(
"Loot Finder",
"Enable loose item looting",
SettingsDefaults,
new ConfigDescription(
"Enables loose item looting for the selected bot types",
null,
new ConfigurationManagerAttributes { Order = 6 }
)
);
DetectItemDistance = Config.Bind(
"Loot Finder",
"Detect item distance",
75f,
new ConfigDescription(
"Distance (in meters) a bot is able to detect an item",
null,
new ConfigurationManagerAttributes { Order = 5 }
)
);
TimeToWaitBetweenLoot = Config.Bind(
"Loot Finder",
"Delay between looting",
15f,
new ConfigDescription(
"The amount of time the bot will wait after looting an container/item/corpse before trying to find the next nearest item/container/corpse",
null,
new ConfigurationManagerAttributes { Order = 2 }
)
);
LootingLogLevels = Config.Bind(
"Loot Finder",
"Log Levels",
LogLevel.Error | LogLevel.Info,
new ConfigDescription(
"Enable different levels of log messages to show in the logs",
null,
new ConfigurationManagerAttributes { Order = 1 }
)
);
DebugLootNavigation = Config.Bind(
"Loot Finder",
"Debug: Show navigation points",
false,
new ConfigDescription(
"Renders shperes where bots are trying to navigate when container looting. (Red): Container position. (Black): 'Optimized' container position. (Green): Calculated bot destination. (Blue): NavMesh corrected destination (where the bot will move).",
null,
new ConfigurationManagerAttributes { Order = 0 }
)
);
}
public void LootSettings()
{
UseMarketPrices = Config.Bind(
"Loot Settings",
"Use flea market prices",
false,
new ConfigDescription(
"Bots will query more accurate ragfair prices to do item value checks. Will make a query to get ragfair prices when the client is first started",
null,
new ConfigurationManagerAttributes { Order = 10 }
)
);
ValueFromMods = Config.Bind(
"Loot Settings",
"Calculate weapon value from attachments",
true,
new ConfigDescription(
"Calculate weapon value by looking up each attachement. More accurate than just looking at the base weapon template but a slightly more expensive check",
null,
new ConfigurationManagerAttributes { Order = 9 }
)
);
CanStripAttachments = Config.Bind(
"Loot Settings",
"Allow weapon attachment stripping",
true,
new ConfigDescription(
"Allows bots to take the attachments off of a weapon if they are not able to pick the weapon up into their inventory",
null,
new ConfigurationManagerAttributes { Order = 8 }
)
);
PMCLootThreshold = Config.Bind(
"Loot Settings",
"PMC: Loot value threshold",
12000f,
new ConfigDescription(
"PMC bots will only loot items that exceed the specified value in roubles",
null,
new ConfigurationManagerAttributes { Order = 6 }
)
);
PMCGearToEquip = Config.Bind(
"Loot Settings",
"PMC: Allowed gear to equip",
EquipmentType.All,
new ConfigDescription(
"The equipment a PMC bot is able to equip during raid",
null,
new ConfigurationManagerAttributes { Order = 5 }
)
);
PMCGearToPickup = Config.Bind(
"Loot Settings",
"PMC: Allowed gear in bags",
EquipmentType.All,
new ConfigDescription(
"The equipment a PMC bot is able to place in their backpack/rig",
null,
new ConfigurationManagerAttributes { Order = 4 }
)
);
ScavLootThreshold = Config.Bind(
"Loot Settings",
"Scav: Loot value threshold",
5000f,
new ConfigDescription(
"All non-PMC bots will only loot items that exceed the specified value in roubles.",
null,
new ConfigurationManagerAttributes { Order = 3 }
)
);
ScavGearToEquip = Config.Bind(
"Loot Settings",
"Scav: Allowed gear to equip",
EquipmentType.All,
new ConfigDescription(
"The equipment a non-PMC bot is able to equip during raid",
null,
new ConfigurationManagerAttributes { Order = 2 }
)
);
ScavGearToPickup = Config.Bind(
"Loot Settings",
"Scav: Allowed gear in bags",
EquipmentType.All,
new ConfigDescription(
"The equipment a non-PMC bot is able to place in their backpack/rig",
null,
new ConfigurationManagerAttributes { Order = 1 }
)
);
ItemAppraiserLogLevels = Config.Bind(
"Loot Settings",
"Log Levels",
LogLevel.Error,
new ConfigDescription(
"Enables logs for the item apprasier that calcualtes the weapon values",
null,
new ConfigurationManagerAttributes { Order = 0 }
)
);
}
public void Awake()
{
LootFinderSettings();
LootSettings();
LootLog = new Log(Logger, LootingLogLevels);
ItemAppraiserLog = new Log(Logger, ItemAppraiserLogLevels);
new SettingsAndCachePatch().Enable();
new RemoveComponent().Enable();
BrainManager.RemoveLayer(
"Utility peace",
new List<string>()
{
"Assault",
"ExUsec",
"BossSanitar",
"CursAssault",
"PMC",
"SectantWarrior"
}
);
BrainManager.AddCustomLayer(
typeof(LootingLayer),
new List<string>()
{
"Assault",
"BossSanitar",
"CursAssault",
"BossKojaniy",
"SectantPriest",
"FollowerGluharScout",
"FollowerGluharProtect",
"FollowerGluharAssault",
"BossGluhar",
"Fl_Zraychiy",
"TagillaFollower",
"FollowerSanitar",
"FollowerBully",
"BirdEye",
"BigPipe",
"Knight",
"BossZryachiy",
"Tagilla",
"Killa",
"BossSanitar",
"BossBully"
},
2
);
BrainManager.AddCustomLayer(
typeof(LootingLayer),
new List<string>() { "PMC", "ExUsec" },
3
);
BrainManager.AddCustomLayer(
typeof(LootingLayer),
new List<string>() { "SectantWarrior" },
13
);
}
public void Update()
{
bool shoultInitAppraiser =
(!UseMarketPrices.Value && ItemAppraiser.HandbookData == null)
|| (UseMarketPrices.Value && !ItemAppraiser.MarketInitialized);
// Initialize the itemAppraiser when the BE instance comes online
if (
Singleton<ClientApplication<ISession>>.Instance != null
&& Singleton<HandbookClass>.Instance != null
&& shoultInitAppraiser
)
{
LootLog.LogInfo($"Initializing item appraiser");
ItemAppraiser.Init();
}
}
}
}
| LootingBots/LootingBots.cs | Skwizzy-SPT-LootingBots-76279a3 | [
{
"filename": "LootingBots/utils/BotTypes.cs",
"retrieved_chunk": "using System;\nusing EFT;\nnamespace LootingBots.Patch.Util\n{\n [Flags]\n public enum BotType\n {\n Scav = 1,\n Pmc = 2,\n Raider = 4,",
"score": 0.8104938268661499
},
{
"filename": "LootingBots/logics/PeacefulLogic.cs",
"retrieved_chunk": "using DrakiaXYZ.BigBrain.Brains;\nusing EFT;\nusing PeacefulNodeClass = GClass177;\nnamespace LootingBots.Brain.Logics\n{\n internal class PeacefulLogic : CustomLogic\n {\n private readonly PeacefulNodeClass _baseLogic;\n // PatrolAssault peaceful logic\n public PeacefulLogic(BotOwner botOwner) : base(botOwner)",
"score": 0.7645055055618286
},
{
"filename": "LootingBots/components/TransactionController.cs",
"retrieved_chunk": "using GridCacheClass = GClass1384;\nnamespace LootingBots.Patch.Components\n{\n public class TransactionController\n {\n readonly BotLog _log;\n readonly InventoryControllerClass _inventoryController;\n readonly BotOwner _botOwner;\n public bool Enabled;\n public TransactionController(",
"score": 0.752226710319519
},
{
"filename": "LootingBots/patches/SettingsAndCache.cs",
"retrieved_chunk": "using System.Reflection;\nusing Aki.Reflection.Patching;\nusing EFT;\nusing LootingBots.Patch.Util;\nnamespace LootingBots.Patch\n{\n public class SettingsAndCachePatch\n {\n public void Enable()\n {",
"score": 0.7515210509300232
},
{
"filename": "LootingBots/utils/EquipmentTypes.cs",
"retrieved_chunk": "using System;\nusing EFT.InventoryLogic;\nusing BodyArmorClass = GClass2538;\nusing HeadArmorClass = GClass2537;\nusing BackpackItemClass = GClass2584;\nusing TacticalRigItemClass = GClass2585;\nnamespace LootingBots.Patch.Util\n{\n [Flags]\n public enum EquipmentType",
"score": 0.7353256344795227
}
] | csharp | BotType SettingsDefaults = BotType.Scav | BotType.Pmc | BotType.Raider; |
using Microsoft.Azure.Cosmos;
using System.Net;
namespace CloudDistributedLock
{
public class CosmosLockClient
{
private readonly CloudDistributedLockProviderOptions options;
private readonly Container container;
public CosmosLockClient(CloudDistributedLockProviderOptions options)
{
this.options = options;
this.container = options.CosmosClient!.GetContainer(options.DatabaseName, options.ContainerName);
}
public async Task<ItemResponse<LockRecord>?> TryAquireLockAsync(string name)
{
try
{
/* This will successfully insert the document if no other process is currently holding a lock.
* The collection is set with a TTL so that the record will be deleted automatically,
* releasing the lock in the event that it is not released by the holder.
* */
var safeLockName = GenerateSafeLockName(name);
var now = DateTimeOffset.UtcNow;
var lockRecord = new LockRecord { id = safeLockName, name = name, providerName = options.ProviderName, lockObtainedAt = now, lockLastRenewedAt = now, _ttl = options.TTL };
return await container.CreateItemAsync(lockRecord, new PartitionKey(lockRecord.id));
}
catch (CosmosException ex)
{
if (ex.StatusCode == HttpStatusCode.Conflict)
{
// lock already held by someone else
return null;
}
throw;
}
}
public async Task<ItemResponse< | LockRecord>?> RenewLockAsync(ItemResponse<LockRecord> item)
{ |
try
{
var lockRecord = item.Resource;
lockRecord.lockLastRenewedAt = DateTimeOffset.UtcNow;
return await container.UpsertItemAsync(lockRecord, new PartitionKey(lockRecord.id), new ItemRequestOptions { IfMatchEtag = item.ETag });
}
catch (CosmosException ex)
{
if (ex.StatusCode == HttpStatusCode.PreconditionFailed)
{
// someone else already acquired a new lock, which means our lock was already released
return null;
}
throw;
}
}
public async Task ReleaseLockAsync(ItemResponse<LockRecord> item)
{
try
{
var lockRecord = item.Resource;
_ = await container.DeleteItemAsync<LockRecord>(lockRecord.id, new PartitionKey(lockRecord.id), new ItemRequestOptions { IfMatchEtag = item.ETag });
}
catch (CosmosException ex)
{
if (ex.StatusCode == HttpStatusCode.PreconditionFailed)
{
// someone else already acquired a new lock, which means our lock was already released
}
}
}
private static string GenerateSafeLockName(string lockName)
{
//'/', '\\', '?', '#' are invalid
return lockName.Replace('/', '_').Replace('\\', '_').Replace('?', '_').Replace('#', '_');
}
}
}
| CloudDistributedLock/CosmosLockClient.cs | briandunnington-CloudDistributedLock-04f72e6 | [
{
"filename": "CloudDistributedLock/CloudDistributedLock.cs",
"retrieved_chunk": " InitializeKeepAlive(updatedItem);\n }\n else\n {\n // someone else already acquired a new lock, which means our lock was already released\n }\n }\n void InitializeKeepAlive(ItemResponse<LockRecord> item)\n {\n this.currentItem = item;",
"score": 0.8939729928970337
},
{
"filename": "ExampleApp/Functions.cs",
"retrieved_chunk": " response.StatusCode = HttpStatusCode.Conflict;\n response.WriteString(\"OtherLock failed to obtain the lock immediately\");\n }\n return response;\n }\n [Function(\"WaitLock\")]\n public async Task<HttpResponseData> WaitLock([HttpTrigger(AuthorizationLevel.Anonymous, \"get\")] HttpRequestData req)\n {\n var response = req.CreateResponse(HttpStatusCode.OK);\n var lockProvider = lockProviderFactory.GetLockProvider();",
"score": 0.8395469188690186
},
{
"filename": "ExampleApp/Functions.cs",
"retrieved_chunk": " });\n // hold the lock for 10 seconds to demonstrate\n await Task.Delay(TimeSpan.FromSeconds(10));\n }\n else\n {\n response.StatusCode = HttpStatusCode.Conflict;\n response.WriteString(\"TryLock failed to obtain the lock immediately\");\n }\n return response;",
"score": 0.8295683264732361
},
{
"filename": "ExampleApp/Functions.cs",
"retrieved_chunk": " });\n }\n else\n {\n // since no timeout was specified in the AcquireAsync(), this should not get hit\n response.StatusCode = HttpStatusCode.Conflict;\n response.WriteString(\"WaitLock failed to obtain the lock - should not happen\");\n }\n return response;\n }",
"score": 0.8260947465896606
},
{
"filename": "CloudDistributedLock/CloudDistributedLock.cs",
"retrieved_chunk": " {\n // the lock in the DB is essentially an unmanaged resource\n timer?.Dispose();\n _ = ReleaseLock();\n isDisposed = true;\n }\n }\n ~CloudDistributedLock()\n {\n Dispose(disposing: false);",
"score": 0.8213014602661133
}
] | csharp | LockRecord>?> RenewLockAsync(ItemResponse<LockRecord> item)
{ |
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using UserManagement.Data.Models;
#nullable disable
namespace UserManagement.Data.Migrations
{
[DbContext(typeof( | ApplicationDbContext))]
[Migration("20230328162524_initcreate")]
partial class initcreate
{ |
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "7.0.4")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
{
b.Property<string>("Id")
.HasColumnType("nvarchar(450)");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex")
.HasFilter("[NormalizedName] IS NOT NULL");
b.ToTable("AspNetRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<string>("RoleId")
.IsRequired()
.HasColumnType("nvarchar(450)");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("AspNetRoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<string>("UserId")
.IsRequired()
.HasColumnType("nvarchar(450)");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("AspNetUserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderKey")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderDisplayName")
.HasColumnType("nvarchar(max)");
b.Property<string>("UserId")
.IsRequired()
.HasColumnType("nvarchar(450)");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("AspNetUserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
{
b.Property<string>("UserId")
.HasColumnType("nvarchar(450)");
b.Property<string>("RoleId")
.HasColumnType("nvarchar(450)");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("AspNetUserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
{
b.Property<string>("UserId")
.HasColumnType("nvarchar(450)");
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("Name")
.HasColumnType("nvarchar(450)");
b.Property<string>("Value")
.HasColumnType("nvarchar(max)");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("AspNetUserTokens", (string)null);
});
modelBuilder.Entity("UserManagement.Data.Models.ApplicationUser", b =>
{
b.Property<string>("Id")
.HasColumnType("nvarchar(450)");
b.Property<int>("AccessFailedCount")
.HasColumnType("int");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("bit");
b.Property<string>("FirstName")
.HasColumnType("nvarchar(max)");
b.Property<string>("LastName")
.HasColumnType("nvarchar(max)");
b.Property<bool>("LockoutEnabled")
.HasColumnType("bit");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("datetimeoffset");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("PasswordHash")
.HasColumnType("nvarchar(max)");
b.Property<string>("PhoneNumber")
.HasColumnType("nvarchar(max)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("bit");
b.Property<string>("SecurityStamp")
.HasColumnType("nvarchar(max)");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("bit");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex")
.HasFilter("[NormalizedUserName] IS NOT NULL");
b.ToTable("AspNetUsers", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
{
b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
{
b.HasOne("UserManagement.Data.Models.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
{
b.HasOne("UserManagement.Data.Models.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
{
b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("UserManagement.Data.Models.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
{
b.HasOne("UserManagement.Data.Models.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
#pragma warning restore 612, 618
}
}
}
| UserManagement.Data/Migrations/20230328162524_initcreate.Designer.cs | shahedbd-API.UserManagement-dcce5cc | [
{
"filename": "UserManagement.Data/Migrations/ApplicationDbContextModelSnapshot.cs",
"retrieved_chunk": "// <auto-generated />\nusing System;\nusing Microsoft.EntityFrameworkCore;\nusing Microsoft.EntityFrameworkCore.Infrastructure;\nusing Microsoft.EntityFrameworkCore.Metadata;\nusing Microsoft.EntityFrameworkCore.Storage.ValueConversion;\nusing UserManagement.Data.Models;\n#nullable disable\nnamespace UserManagement.Data.Migrations\n{",
"score": 0.7847781181335449
},
{
"filename": "UserManagement.Api/Controllers/AuthenticationController.cs",
"retrieved_chunk": "using UserManagement.Api.Services;\nusing UserManagement.Data.Models;\nusing Microsoft.AspNetCore.Mvc;\nnamespace BloggingApis.Controllers\n{\n [Route(\"api/[controller]\")]\n [ApiController]\n public class AuthenticationController : ControllerBase\n {\n private readonly IAuthService _authService;",
"score": 0.7387905120849609
},
{
"filename": "UserManagement.Data/Models/ApplicationDbContext.cs",
"retrieved_chunk": "using Microsoft.AspNetCore.Identity.EntityFrameworkCore;\nusing Microsoft.EntityFrameworkCore;\nnamespace UserManagement.Data.Models\n{\n public class ApplicationDbContext : IdentityDbContext<ApplicationUser>\n {\n public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)\n {\n }\n }",
"score": 0.7302977442741394
},
{
"filename": "UserManagement.Api/Controllers/UserListController.cs",
"retrieved_chunk": "using Microsoft.AspNetCore.Authorization;\nusing Microsoft.AspNetCore.Http;\nusing Microsoft.AspNetCore.Mvc;\nnamespace BookStore.Api.Controllers\n{\n [Route(\"api/userlist\")]\n [ApiController]\n [Authorize(Roles =\"Admin\")]\n public class UserListController : ControllerBase\n {",
"score": 0.709994912147522
},
{
"filename": "UserManagement.Data/Migrations/20230328162524_initcreate.cs",
"retrieved_chunk": "using System;\nusing Microsoft.EntityFrameworkCore.Migrations;\n#nullable disable\nnamespace UserManagement.Data.Migrations\n{\n /// <inheritdoc />\n public partial class initcreate : Migration\n {\n /// <inheritdoc />\n protected override void Up(MigrationBuilder migrationBuilder)",
"score": 0.6971580982208252
}
] | csharp | ApplicationDbContext))]
[Migration("20230328162524_initcreate")]
partial class initcreate
{ |
using HarmonyLib;
using System;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
namespace Ultrapain.Patches
{
/*public class ObjectActivator : MonoBehaviour
{
public int originalInstanceID = 0;
public MonoBehaviour activator;
void Start()
{
if (gameObject.GetInstanceID() == originalInstanceID)
return;
activator?.Invoke("OnClone", 0f);
}
}*/
public class CommonLinearScaler : MonoBehaviour
{
public Transform targetTransform;
public float scaleSpeed = 1f;
void Update()
{
float deltaSize = Time.deltaTime * scaleSpeed;
targetTransform.localScale = new Vector3(targetTransform.localScale.x + deltaSize, targetTransform.localScale.y + deltaSize, targetTransform.localScale.y + deltaSize);
}
}
public class CommonAudioPitchScaler : MonoBehaviour
{
public AudioSource targetAud;
public float scaleSpeed = 1f;
void Update()
{
float deltaPitch = Time.deltaTime * scaleSpeed;
targetAud.pitch += deltaPitch;
}
}
public class RotateOnSpawn : MonoBehaviour
{
public | Quaternion targetRotation; |
private void Awake()
{
transform.rotation = targetRotation;
}
}
public class CommonActivator : MonoBehaviour
{
public int originalId;
public Renderer rend;
public Rigidbody rb;
public bool kinematic;
public bool colDetect;
public Collider col;
public AudioSource aud;
public List<MonoBehaviour> comps = new List<MonoBehaviour>();
void Awake()
{
if (originalId == gameObject.GetInstanceID())
return;
if (rend != null)
rend.enabled = true;
if (rb != null)
{
rb.isKinematic = kinematic;
rb.detectCollisions = colDetect;
}
if (col != null)
col.enabled = true;
if (aud != null)
aud.enabled = true;
foreach (MonoBehaviour comp in comps)
comp.enabled = true;
foreach (Transform child in gameObject.transform)
child.gameObject.SetActive(true);
}
}
public class GrenadeExplosionOverride : MonoBehaviour
{
public bool harmlessMod = false;
public float harmlessSize = 1f;
public float harmlessSpeed = 1f;
public float harmlessDamage = 1f;
public int harmlessPlayerDamageOverride = -1;
public bool normalMod = false;
public float normalSize = 1f;
public float normalSpeed = 1f;
public float normalDamage = 1f;
public int normalPlayerDamageOverride = -1;
public bool superMod = false;
public float superSize = 1f;
public float superSpeed = 1f;
public float superDamage = 1f;
public int superPlayerDamageOverride = -1;
struct StateInfo
{
public GameObject tempHarmless;
public GameObject tempNormal;
public GameObject tempSuper;
public StateInfo()
{
tempHarmless = tempNormal = tempSuper = null;
}
}
[HarmonyBefore]
static bool Prefix(Grenade __instance, out StateInfo __state)
{
__state = new StateInfo();
GrenadeExplosionOverride flag = __instance.GetComponent<GrenadeExplosionOverride>();
if (flag == null)
return true;
if (flag.harmlessMod)
{
__state.tempHarmless = __instance.harmlessExplosion = GameObject.Instantiate(__instance.harmlessExplosion);
foreach (Explosion exp in __instance.harmlessExplosion.GetComponentsInChildren<Explosion>())
{
exp.damage = (int)(exp.damage * flag.harmlessDamage);
exp.maxSize *= flag.harmlessSize;
exp.speed *= flag.harmlessSize * flag.harmlessSpeed;
exp.playerDamageOverride = flag.harmlessPlayerDamageOverride;
}
}
if (flag.normalMod)
{
__state.tempNormal = __instance.explosion = GameObject.Instantiate(__instance.explosion);
foreach (Explosion exp in __instance.explosion.GetComponentsInChildren<Explosion>())
{
exp.damage = (int)(exp.damage * flag.normalDamage);
exp.maxSize *= flag.normalSize;
exp.speed *= flag.normalSize * flag.normalSpeed;
exp.playerDamageOverride = flag.normalPlayerDamageOverride;
}
}
if (flag.superMod)
{
__state.tempSuper = __instance.superExplosion = GameObject.Instantiate(__instance.superExplosion);
foreach (Explosion exp in __instance.superExplosion.GetComponentsInChildren<Explosion>())
{
exp.damage = (int)(exp.damage * flag.superDamage);
exp.maxSize *= flag.superSize;
exp.speed *= flag.superSize * flag.superSpeed;
exp.playerDamageOverride = flag.superPlayerDamageOverride;
}
}
return true;
}
static void Postfix(StateInfo __state)
{
if (__state.tempHarmless != null)
GameObject.Destroy(__state.tempHarmless);
if (__state.tempNormal != null)
GameObject.Destroy(__state.tempNormal);
if (__state.tempSuper != null)
GameObject.Destroy(__state.tempSuper);
}
}
}
| Ultrapain/Patches/CommonComponents.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/V2Common.cs",
"retrieved_chunk": " return true;\n }\n }\n class V2CommonRevolverBulletSharp : MonoBehaviour\n {\n public int reflectionCount = 2;\n public float autoAimAngle = 30f;\n public Projectile proj;\n public float speed = 350f;\n public bool hasTargetPoint = false;",
"score": 0.868950605392456
},
{
"filename": "Ultrapain/Patches/Stray.cs",
"retrieved_chunk": " /*__instance.projectile = Plugin.homingProjectile;\n __instance.decProjectile = Plugin.decorativeProjectile2;*/\n }\n }\n public class ZombieProjectile_ThrowProjectile_Patch\n {\n public static float normalizedTime = 0f;\n public static float animSpeed = 20f;\n public static float projectileSpeed = 75;\n public static float turnSpeedMultiplier = 0.45f;",
"score": 0.8374632596969604
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " {\n private LeviathanHead comp;\n private Animator anim;\n //private Collider col;\n private LayerMask envMask = new LayerMask() { value = 1 << 8 | 1 << 24 };\n public float playerRocketRideTracker = 0;\n private GameObject currentProjectileEffect;\n private AudioSource currentProjectileAud;\n private Transform shootPoint;\n public float currentProjectileSize = 0;",
"score": 0.8339869379997253
},
{
"filename": "Ultrapain/Patches/SwordsMachine.cs",
"retrieved_chunk": " sm.SendMessage(\"SetSpeed\");\n }\n private void Awake()\n {\n anim = GetComponent<Animator>();\n eid = GetComponent<EnemyIdentifier>();\n }\n public float speed = 1f;\n private void Update()\n {",
"score": 0.8298383951187134
},
{
"filename": "Ultrapain/Patches/V2First.cs",
"retrieved_chunk": " public Collider v2collider;\n public float punchCooldown = 0f;\n public Transform targetGrenade;\n void Update()\n {\n if (punchCooldown > 0)\n punchCooldown = Mathf.MoveTowards(punchCooldown, 0f, Time.deltaTime);\n }\n public void PunchShockwave()\n {",
"score": 0.8295544981956482
}
] | csharp | Quaternion targetRotation; |
using LibreDteDotNet.Common.Models;
using LibreDteDotNet.RestRequest.Interfaces;
namespace LibreDteDotNet.RestRequest.Extensions
{
public static class DTEExtension
{
public static IDTE Conectar(this IDTE folioService)
{
IDTE instance = folioService;
return instance.SetCookieCertificado().ConfigureAwait(false).GetAwaiter().GetResult();
}
public static async Task< | IDTE> Validar(this IDTE folioService, string pathfile)
{ |
if (!File.Exists(pathfile))
{
throw new Exception($"El Documento no existe en la ruta {pathfile}");
}
IDTE instance = folioService;
return await instance.Validar<EnvioDTE>(pathfile);
}
public static async Task<string> Enviar(
this Task<IDTE> folioService,
string rutCompany,
string DvCompany
)
{
IDTE instance = await folioService;
return await instance.Enviar(rutCompany, DvCompany);
}
}
}
| LibreDteDotNet.RestRequest/Extensions/DTEExtension.cs | sergiokml-LibreDteDotNet.RestRequest-6843109 | [
{
"filename": "LibreDteDotNet.RestRequest/Extensions/BoletaExtension.cs",
"retrieved_chunk": "using LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class BoletaExtension\n {\n public static IBoleta Conectar(this IBoleta folioService)\n {\n IBoleta instance = folioService;\n return instance.SetCookieCertificado().Result;\n }",
"score": 0.8528377413749695
},
{
"filename": "LibreDteDotNet.RestRequest/Extensions/FolioCafExtension.cs",
"retrieved_chunk": " }\n public static async Task<XDocument> Descargar(this Task<IFolioCaf> instance)\n {\n return await (await instance).Descargar();\n }\n public static async Task<IFolioCaf> Confirmar(this Task<IFolioCaf> instance)\n {\n return await (await instance).Confirmar();\n }\n }",
"score": 0.8403838276863098
},
{
"filename": "LibreDteDotNet.RestRequest/Extensions/FolioCafExtension.cs",
"retrieved_chunk": "using System.Xml.Linq;\nusing LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class FolioCafExtension\n {\n private static CancellationToken CancellationToken { get; set; }\n public static IFolioCaf Conectar(this IFolioCaf instance)\n {\n return instance.SetCookieCertificado().Result;",
"score": 0.8235564827919006
},
{
"filename": "LibreDteDotNet.RestRequest/Services/DTEService.cs",
"retrieved_chunk": " }\n public async Task<string> GetInfoDte(\n string rutCompany,\n string dvCompany,\n TipoDoc tipoDTE,\n string folioDTE\n )\n {\n _ = await SetCookieCertificado(Properties.Resources.UrlValidaDte);\n if (HttpStatCode != HttpStatusCode.OK)",
"score": 0.819206714630127
},
{
"filename": "LibreDteDotNet.RestRequest/Extensions/ContribuyenteExtension.cs",
"retrieved_chunk": "using LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class ContribuyenteExtension\n {\n public static IContribuyente Conectar(this IContribuyente folioService)\n {\n IContribuyente instance = folioService;\n return instance.SetCookieCertificado().Result;\n }",
"score": 0.8189926147460938
}
] | csharp | IDTE> Validar(this IDTE folioService, string pathfile)
{ |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
using System.Security.Cryptography.X509Certificates;
using Azure.Core;
using Azure.Identity;
using Azure.Security.KeyVault.Certificates;
using Azure.Security.KeyVault.Secrets;
using GraphNotifications.Models;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace GraphNotifications.Services
{
/// <summary>
/// Implements methods to retrieve certificates from Azure Key Vault
/// </summary>
public class CertificateService : ICertificateService
{
private readonly AppSettings _settings;
private readonly ILogger _logger;
private readonly Uri _keyVaultUrl;
private byte[] _publicKeyBytes = null;
private byte[] _privateKeyBytes = null;
public CertificateService(IOptions< | AppSettings> options, ILogger<CertificateService> logger)
{ |
_settings = options.Value;
_logger = logger;
_keyVaultUrl = !string.IsNullOrEmpty(_settings.KeyVaultUrl) ?
new Uri(_settings.KeyVaultUrl) : throw new ArgumentNullException(nameof(_settings.KeyVaultUrl));
}
/// <summary>
/// Gets the configured public key from the Azure Key Vault
/// </summary>
/// <returns>The public key</returns>
public async Task<X509Certificate2> GetEncryptionCertificate()
{
if (_publicKeyBytes == null)
{
await LoadCertificates();
}
return new X509Certificate2(_publicKeyBytes);
}
/// <summary>
/// Gets the configure private key from the Azure Key Vault
/// </summary>
/// <returns>The private key</returns>
public async Task<X509Certificate2> GetDecryptionCertificate()
{
if (_privateKeyBytes == null)
{
await LoadCertificates();
}
return new X509Certificate2(_privateKeyBytes);
}
private TokenCredential GetCredential()
{
// If you granted your Application access to the key vault
// you can use clientId and Client Secret
if (_settings.UseClientSecretAuth)
{
var tenantId = _settings.TenantId;
var clientId = _settings.ClientId;
var clientSecret = _settings.ClientSecret;
// Authenticate as the app to connect to Azure Key Vault
return new ClientSecretCredential(tenantId, clientId, clientSecret);
}
// If using user assigned managed identity
// pass the client id of the identity
var userAssignedClientId = _settings.UserAssignedClientId;
if (!string.IsNullOrEmpty(userAssignedClientId))
{
return new DefaultAzureCredential(new DefaultAzureCredentialOptions { ManagedIdentityClientId = userAssignedClientId });
}
// If using system assigned managed identity
// or local development
// Authenticate as the app to connect to Azure Key Vault
var defaultAzureCredentialOptions = new DefaultAzureCredentialOptions();
defaultAzureCredentialOptions.ExcludeAzureCliCredential = false;
defaultAzureCredentialOptions.ExcludeEnvironmentCredential = true;
defaultAzureCredentialOptions.ExcludeInteractiveBrowserCredential = true;
defaultAzureCredentialOptions.ExcludeManagedIdentityCredential = false;
defaultAzureCredentialOptions.ExcludeSharedTokenCacheCredential = true;
defaultAzureCredentialOptions.ExcludeVisualStudioCodeCredential = false;
defaultAzureCredentialOptions.ExcludeVisualStudioCredential = false;
return new DefaultAzureCredential(defaultAzureCredentialOptions);
}
/// <summary>
/// Gets the public and private keys from Azure Key Vault and caches the raw values
/// </summary>
private async Task LoadCertificates()
{
// Load configuration values
var certificateName = _settings.CertificateName;
var credential = GetCredential();
// CertificateClient can get the public key
var certClient = new CertificateClient(_keyVaultUrl, credential);
// Secret client can get the private key
var secretClient = new SecretClient(_keyVaultUrl, credential);
// Get the public key
var publicCertificate = await certClient.GetCertificateAsync(certificateName);
// Each certificate that has a private key in Azure Key Vault has a corresponding
// secret ID. Use this to get the private key
var privateCertificate = await secretClient.GetSecretAsync(ParseSecretName(publicCertificate.Value.SecretId));
_publicKeyBytes = publicCertificate.Value.Cer;
_privateKeyBytes = Convert.FromBase64String(privateCertificate.Value.Value);
}
/// <summary>
/// Extract the secret name from the secret ID
/// </summary>
/// <param name="secretId">The URI to the secret</param>
/// <returns>The secret name</returns>
/// <exception cref="InvalidOperationException"></exception>
private static string ParseSecretName(Uri secretId)
{
// Secret IDs are URIs. The name is in the
// third segment
if (secretId.Segments.Length < 3)
{
throw new InvalidOperationException($@"The secret ""{secretId}"" does not contain a valid name.");
}
return secretId.Segments[2].TrimEnd('/');
}
}
}
| Services/CertificateService.cs | microsoft-GraphNotificationBroker-b1564aa | [
{
"filename": "Services/GraphClientService.cs",
"retrieved_chunk": " {\n private readonly AppSettings _settings;\n private readonly ILogger _logger;\n public GraphClientService(IOptions<AppSettings> options, ILogger<GraphClientService> logger)\n {\n _settings = options.Value;\n _logger = logger;\n }\n public GraphServiceClient GetUserGraphClient(string userAssertion)\n {",
"score": 0.880663275718689
},
{
"filename": "Services/RedisFactory.cs",
"retrieved_chunk": " /// </summary> \n public class RedisFactory : IRedisFactory\n {\n private static Lazy<IConnectionMultiplexer> _multiplexer;\n private static Lazy<IDatabase> _cache;\n private bool _disposed = false;\n private readonly AppSettings _settings;\n private readonly ILogger<RedisFactory> _logger;\n // Force Reconnect variables\n static long lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;",
"score": 0.8383904099464417
},
{
"filename": "Services/CacheService.cs",
"retrieved_chunk": " /// <summary>\n /// Implements connection to Redis\n /// </summary> \n public class CacheService : ICacheService\n {\n private readonly ILogger<CacheService> _logger;\n private readonly IRedisFactory _redisFactory;\n private static readonly Encoding encoding = Encoding.UTF8;\n public CacheService(IRedisFactory redisFactory, ILogger<CacheService> logger)\n {",
"score": 0.8351763486862183
},
{
"filename": "Functions/GraphNotificationsHub.cs",
"retrieved_chunk": " private readonly ICertificateService _certificateService;\n private readonly ICacheService _cacheService;\n private readonly ILogger _logger;\n private readonly AppSettings _settings;\n private const string MicrosoftGraphChangeTrackingSpId = \"0bf30f3b-4a52-48df-9a82-234910c4a086\";\n public GraphNotificationsHub(\n ITokenValidationService tokenValidationService,\n IGraphNotificationService graphNotificationService,\n ICacheService cacheService,\n ICertificateService certificateService,",
"score": 0.8286651372909546
},
{
"filename": "Services/TokenValidationService.cs",
"retrieved_chunk": " private static readonly Lazy<JwtSecurityTokenHandler> JwtSecurityTokenHandler = new Lazy<JwtSecurityTokenHandler>(() => new JwtSecurityTokenHandler());\n public TokenValidationService(IOptions<AppSettings> settings, ILogger<TokenValidationService> logger)\n {\n _settings = settings.Value;\n _logger = logger;\n }\n public async Task<TokenValidationResult?> ValidateTokenAsync(string token)\n {\n var validationParameters = await GetTokenValidationParametersAsync();\n if (validationParameters == null)",
"score": 0.8197581768035889
}
] | csharp | AppSettings> options, ILogger<CertificateService> logger)
{ |
#nullable enable
using System;
using System.Collections.Generic;
using System.Threading;
using Cysharp.Threading.Tasks;
using Mochineko.Relent.Result;
namespace Mochineko.RelentStateMachine
{
public sealed class StackStateMachine<TContext>
: IStackStateMachine<TContext>
{
private readonly IStateStore<TContext> stateStore;
public TContext Context { get; }
private readonly Stack<IStackState<TContext>> stack = new();
public bool IsCurrentState<TState>()
where TState : | IStackState<TContext>
=> stack.Peek() is TState; |
private readonly SemaphoreSlim semaphore = new(
initialCount: 1,
maxCount: 1);
private readonly TimeSpan semaphoreTimeout;
private const float DefaultSemaphoreTimeoutSeconds = 30f;
public static async UniTask<StackStateMachine<TContext>> CreateAsync(
IStateStore<TContext> stateStore,
TContext context,
CancellationToken cancellationToken,
TimeSpan? semaphoreTimeout = null)
{
var instance = new StackStateMachine<TContext>(
stateStore,
context,
semaphoreTimeout);
await instance.stack.Peek()
.EnterAsync(context, cancellationToken);
return instance;
}
private StackStateMachine(
IStateStore<TContext> stateStore,
TContext context,
TimeSpan? semaphoreTimeout = null)
{
this.stateStore = stateStore;
this.Context = context;
this.stack.Push(this.stateStore.InitialState);
this.semaphoreTimeout =
semaphoreTimeout
?? TimeSpan.FromSeconds(DefaultSemaphoreTimeoutSeconds);
}
public void Dispose()
{
semaphore.Dispose();
stack.Clear();
stateStore.Dispose();
}
public async UniTask<IResult<IPopToken>> PushAsync<TState>(
CancellationToken cancellationToken)
where TState : IStackState<TContext>
{
// Make stack thread-safe.
try
{
await semaphore.WaitAsync(semaphoreTimeout, cancellationToken);
}
catch (OperationCanceledException exception)
{
semaphore.Release();
return Results.Fail<IPopToken>(
$"Cancelled to wait semaphore because of {exception}.");
}
var nextState = stateStore.Get<TState>();
try
{
await nextState.EnterAsync(Context, cancellationToken);
stack.Push(nextState);
return Results.Succeed(PopToken.Publish(this));
}
finally
{
semaphore.Release();
}
}
public async UniTask UpdateAsync(CancellationToken cancellationToken)
{
var currentState = stack.Peek();
await currentState.UpdateAsync(Context, cancellationToken);
}
private sealed class PopToken : IPopToken
{
private readonly StackStateMachine<TContext> publisher;
private bool popped = false;
public static IPopToken Publish(StackStateMachine<TContext> publisher)
=> new PopToken(publisher);
private PopToken(StackStateMachine<TContext> publisher)
{
this.publisher = publisher;
}
public async UniTask<IResult> PopAsync(CancellationToken cancellationToken)
{
if (popped)
{
throw new InvalidOperationException(
$"Failed to pop because of already popped.");
}
if (publisher.stack.Count is 0)
{
throw new InvalidOperationException(
$"Failed to pop because of stack is empty.");
}
// Make stack thread-safe.
try
{
await publisher.semaphore
.WaitAsync(publisher.semaphoreTimeout, cancellationToken);
}
catch (OperationCanceledException exception)
{
publisher.semaphore.Release();
return Results.Fail(
$"Cancelled to wait semaphore because of {exception}.");
}
popped = true;
var currentState = publisher.stack.Peek();
try
{
await currentState
.ExitAsync(publisher.Context, cancellationToken);
publisher.stack.Pop();
return Results.Succeed();
}
finally
{
publisher.semaphore.Release();
}
}
}
}
} | Assets/Mochineko/RelentStateMachine/StackStateMachine.cs | mochi-neko-RelentStateMachine-64762eb | [
{
"filename": "Assets/Mochineko/RelentStateMachine/FiniteStateMachine.cs",
"retrieved_chunk": " private readonly ITransitionMap<TEvent, TContext> transitionMap;\n public TContext Context { get; }\n private IState<TEvent, TContext> currentState;\n public bool IsCurrentState<TState>()\n where TState : IState<TEvent, TContext>\n => currentState is TState;\n private readonly SemaphoreSlim semaphore = new(\n initialCount: 1,\n maxCount: 1);\n private readonly TimeSpan semaphoreTimeout;",
"score": 0.9179983139038086
},
{
"filename": "Assets/Mochineko/RelentStateMachine/StateStoreBuilder.cs",
"retrieved_chunk": " private bool disposed = false;\n public static StateStoreBuilder<TContext> Create<TInitialState>()\n where TInitialState : IStackState<TContext>, new()\n {\n var initialState = new TInitialState();\n return new StateStoreBuilder<TContext>(initialState);\n }\n private StateStoreBuilder(IStackState<TContext> initialState)\n {\n this.initialState = initialState;",
"score": 0.9108100533485413
},
{
"filename": "Assets/Mochineko/RelentStateMachine/StateStoreBuilder.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nnamespace Mochineko.RelentStateMachine\n{\n public sealed class StateStoreBuilder<TContext>\n : IStateStoreBuilder<TContext>\n {\n private readonly IStackState<TContext> initialState;\n private readonly List<IStackState<TContext>> states = new();",
"score": 0.892822802066803
},
{
"filename": "Assets/Mochineko/RelentStateMachine/StateStore.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nnamespace Mochineko.RelentStateMachine\n{\n public sealed class StateStore<TContext> : IStateStore<TContext>\n {\n private readonly IStackState<TContext> initialState;\n private readonly IReadOnlyList<IStackState<TContext>> states;\n public StateStore(",
"score": 0.8883743286132812
},
{
"filename": "Assets/Mochineko/RelentStateMachine/IStateStore.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nnamespace Mochineko.RelentStateMachine\n{\n public interface IStateStore<TContext> : IDisposable\n {\n internal IStackState<TContext> InitialState { get; }\n internal IStackState<TContext> Get<TState>() where TState : IStackState<TContext>;\n }\n}",
"score": 0.887633204460144
}
] | csharp | IStackState<TContext>
=> stack.Peek() is TState; |
using System;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace Ultrapain.Patches
{
class SomethingWickedFlag : MonoBehaviour
{
public GameObject spear;
public MassSpear spearComp;
public EnemyIdentifier eid;
public | Transform spearOrigin; |
public Rigidbody spearRb;
public static float SpearTriggerDistance = 80f;
public static LayerMask envMask = new LayerMask() { value = (1 << 8) | (1 << 24) };
void Awake()
{
if (eid == null)
eid = GetComponent<EnemyIdentifier>();
if (spearOrigin == null)
{
GameObject obj = new GameObject();
obj.transform.parent = transform;
obj.transform.position = GetComponent<Collider>().bounds.center;
obj.SetActive(false);
spearOrigin = obj.transform;
}
}
void Update()
{
if(spear == null)
{
Vector3 playerCenter = NewMovement.Instance.playerCollider.bounds.center;
float distanceFromPlayer = Vector3.Distance(spearOrigin.position, playerCenter);
if (distanceFromPlayer < SpearTriggerDistance)
{
if(!Physics.Raycast(transform.position, playerCenter - transform.position, distanceFromPlayer, envMask))
{
spear = GameObject.Instantiate(Plugin.hideousMassSpear, transform);
spear.transform.position = spearOrigin.position;
spear.transform.LookAt(playerCenter);
spear.transform.position += spear.transform.forward * 5;
spearComp = spear.GetComponent<MassSpear>();
spearRb = spearComp.GetComponent<Rigidbody>();
spearComp.originPoint = spearOrigin;
spearComp.damageMultiplier = 0f;
spearComp.speedMultiplier = 2;
}
}
}
else if(spearComp.beenStopped)
{
if (!spearComp.transform.parent || spearComp.transform.parent.tag != "Player")
if(spearRb.isKinematic == true)
GameObject.Destroy(spear);
}
}
}
class SomethingWicked_Start
{
static void Postfix(Wicked __instance)
{
SomethingWickedFlag flag = __instance.gameObject.AddComponent<SomethingWickedFlag>();
}
}
class SomethingWicked_GetHit
{
static void Postfix(Wicked __instance)
{
SomethingWickedFlag flag = __instance.GetComponent<SomethingWickedFlag>();
if (flag == null)
return;
if (flag.spear != null)
GameObject.Destroy(flag.spear);
}
}
class JokeWicked : MonoBehaviour
{
void OnDestroy()
{
MusicManager.Instance.ForceStartMusic();
}
}
class JokeWicked_GetHit
{
static void Postfix(Wicked __instance)
{
if (__instance.GetComponent<JokeWicked>() == null)
return;
GameObject.Destroy(__instance.gameObject);
}
}
class ObjectActivator_Activate
{
static bool Prefix(ObjectActivator __instance)
{
if (SceneManager.GetActiveScene().name != "38748a67bc9e67a43956a92f87d1e742")
return true;
if(__instance.name == "Scream")
{
GameObject goreZone = new GameObject();
goreZone.AddComponent<GoreZone>();
Vector3 spawnPos = new Vector3(86.7637f, -39.9667f, 635.7572f);
if (Physics.Raycast(spawnPos + Vector3.up, Vector3.down, out RaycastHit hit, 100f, new LayerMask() { value = (1 << 8) | (1 << 24) }, QueryTriggerInteraction.Ignore))
spawnPos = hit.point;
GameObject wicked = GameObject.Instantiate(Plugin.somethingWicked, spawnPos, Quaternion.identity, goreZone.transform); ;
wicked.AddComponent<JokeWicked>();
Wicked comp = wicked.GetComponent<Wicked>();
comp.patrolPoints = new Transform[] { __instance.transform };
wicked.AddComponent<JokeWicked>();
}
else if(__instance.name == "Hint 1")
{
return false;
}
return true;
}
}
}
| Ultrapain/Patches/SomethingWicked.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Virtue.cs",
"retrieved_chunk": " }\n }\n class VirtueFlag : MonoBehaviour\n {\n public AudioSource lighningBoltSFX;\n public GameObject ligtningBoltAud;\n public Transform windupObj;\n private EnemyIdentifier eid;\n public Drone virtue;\n public void Awake()",
"score": 0.8850671052932739
},
{
"filename": "Ultrapain/Patches/Parry.cs",
"retrieved_chunk": "using HarmonyLib;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class GrenadeParriedFlag : MonoBehaviour\n {\n public int parryCount = 1;\n public bool registeredStyle = false;\n public bool bigExplosionOverride = false;\n public GameObject temporaryExplosion;",
"score": 0.8839124441146851
},
{
"filename": "Ultrapain/Patches/SwordsMachine.cs",
"retrieved_chunk": "using HarmonyLib;\nusing System.Security.Cryptography;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class SwordsMachineFlag : MonoBehaviour\n {\n public SwordsMachine sm;\n public Animator anim;\n public EnemyIdentifier eid;",
"score": 0.8713677525520325
},
{
"filename": "Ultrapain/Patches/Cerberus.cs",
"retrieved_chunk": "using UnityEngine;\nnamespace Ultrapain.Patches\n{\n class CerberusFlag : MonoBehaviour\n {\n public int extraDashesRemaining = ConfigManager.cerberusTotalDashCount.value - 1;\n public Transform head;\n public float lastParryTime;\n private EnemyIdentifier eid;\n private void Awake()",
"score": 0.8680800795555115
},
{
"filename": "Ultrapain/Patches/HideousMass.cs",
"retrieved_chunk": "using HarmonyLib;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n public class HideousMassProjectile : MonoBehaviour\n {\n public float damageBuf = 1f;\n public float speedBuf = 1f;\n }\n public class Projectile_Explode_Patch ",
"score": 0.8650003671646118
}
] | csharp | Transform spearOrigin; |
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using System;
using System.Collections.Generic;
using System.Text;
namespace Microsoft.Build.Utilities
{
internal static class DependencyTableCache
{
private class TaskItemItemSpecIgnoreCaseComparer : IEqualityComparer<ITaskItem>
{
public bool Equals(ITaskItem x, ITaskItem y)
{
if (x == y)
{
return true;
}
if (x == null || y == null)
{
return false;
}
return string.Equals(x.ItemSpec, y.ItemSpec, StringComparison.OrdinalIgnoreCase);
}
public int GetHashCode(ITaskItem obj)
{
if (obj != null)
{
return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.ItemSpec);
}
return 0;
}
}
private static readonly char[] s_numerals = new char[10] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
private static readonly TaskItemItemSpecIgnoreCaseComparer s_taskItemComparer = new TaskItemItemSpecIgnoreCaseComparer();
internal static Dictionary<string, | DependencyTableCacheEntry> DependencyTable { | get; } = new Dictionary<string, DependencyTableCacheEntry>(StringComparer.OrdinalIgnoreCase);
private static bool DependencyTableIsUpToDate(DependencyTableCacheEntry dependencyTable)
{
DateTime tableTime = dependencyTable.TableTime;
ITaskItem[] tlogFiles = dependencyTable.TlogFiles;
for (int i = 0; i < tlogFiles.Length; i++)
{
if (NativeMethods.GetLastWriteFileUtcTime(FileUtilities.NormalizePath(tlogFiles[i].ItemSpec)) > tableTime)
{
return false;
}
}
return true;
}
internal static DependencyTableCacheEntry GetCachedEntry(string tLogRootingMarker)
{
if (DependencyTable.TryGetValue(tLogRootingMarker, out var value))
{
if (DependencyTableIsUpToDate(value))
{
return value;
}
DependencyTable.Remove(tLogRootingMarker);
}
return null;
}
internal static string FormatNormalizedTlogRootingMarker(ITaskItem[] tlogFiles)
{
HashSet<ITaskItem> hashSet = new HashSet<ITaskItem>(s_taskItemComparer);
for (int i = 0; i < tlogFiles.Length; i++)
{
ITaskItem taskItem = new TaskItem(tlogFiles[i]);
taskItem.ItemSpec = NormalizeTlogPath(tlogFiles[i].ItemSpec);
hashSet.Add(taskItem);
}
return FileTracker.FormatRootingMarker(hashSet.ToArray());
}
private static string NormalizeTlogPath(string tlogPath)
{
if (tlogPath.IndexOfAny(s_numerals) == -1)
{
return tlogPath;
}
StringBuilder stringBuilder = new StringBuilder();
int num = tlogPath.Length - 1;
while (num >= 0 && tlogPath[num] != '\\')
{
if (tlogPath[num] == '.' || tlogPath[num] == '-')
{
stringBuilder.Append(tlogPath[num]);
int num2 = num - 1;
while (num2 >= 0 && tlogPath[num2] != '\\' && tlogPath[num2] >= '0' && tlogPath[num2] <= '9')
{
num2--;
}
if (num2 >= 0 && tlogPath[num2] == '.')
{
stringBuilder.Append("]DI[");
stringBuilder.Append(tlogPath[num2]);
num = num2;
}
}
else
{
stringBuilder.Append(tlogPath[num]);
}
num--;
}
StringBuilder stringBuilder2 = new StringBuilder(num + stringBuilder.Length);
if (num >= 0)
{
stringBuilder2.Append(tlogPath, 0, num + 1);
}
for (int num3 = stringBuilder.Length - 1; num3 >= 0; num3--)
{
stringBuilder2.Append(stringBuilder[num3]);
}
return stringBuilder2.ToString();
}
}
}
| Microsoft.Build.Utilities/DependencyTableCache.cs | Chuyu-Team-MSBuildCppCrossToolset-6c84a69 | [
{
"filename": "Microsoft.Build.CPPTasks/VCToolTask.cs",
"retrieved_chunk": " rhs = messageStruct;\n }\n }\n private Dictionary<string, ToolSwitch> activeToolSwitchesValues = new Dictionary<string, ToolSwitch>();\n#if __REMOVE\n private IntPtr cancelEvent;\n private string cancelEventName;\n#endif\n private bool fCancelled;\n private Dictionary<string, ToolSwitch> activeToolSwitches = new Dictionary<string, ToolSwitch>(StringComparer.OrdinalIgnoreCase);",
"score": 0.7785282135009766
},
{
"filename": "Microsoft.Build.Utilities/CanonicalTrackedInputFiles.cs",
"retrieved_chunk": " }\n }\n DependencyTable = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);\n if (_tlogFiles != null)\n {\n ConstructDependencyTable();\n }\n }\n public ITaskItem[] ComputeSourcesNeedingCompilation()\n {",
"score": 0.7606300115585327
},
{
"filename": "Microsoft.Build.CPPTasks/VCToolTask.cs",
"retrieved_chunk": " foreach (ITaskItem taskItem in value)\n {\n errorListRegexListExclusion.Add(new Regex(taskItem.ItemSpec, RegexOptions.IgnoreCase | RegexOptions.Compiled, TimeSpan.FromMilliseconds(100.0)));\n }\n }\n }\n public bool EnableErrorListRegex { get; set; } = true;\n public bool ForceSinglelineErrorListRegex { get; set; }\n public virtual string[] AcceptableNonzeroExitCodes { get; set; }\n public Dictionary<string, ToolSwitch> ActiveToolSwitchesValues",
"score": 0.7591351270675659
},
{
"filename": "Microsoft.Build.CPPTasks/VCToolTask.cs",
"retrieved_chunk": " private Dictionary<string, Dictionary<string, string>> values = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);\n private string additionalOptions = string.Empty;\n private char prefix = '/';\n private TaskLoggingHelper logPrivate;\n protected List<Regex> errorListRegexList = new List<Regex>();\n protected List<Regex> errorListRegexListExclusion = new List<Regex>();\n protected MessageStruct lastMS = new MessageStruct();\n protected MessageStruct currentMS = new MessageStruct();\n protected Dictionary<string, ToolSwitch> ActiveToolSwitches => activeToolSwitches;\n protected static Regex FindBackSlashInPath { get; } = new Regex(\"(?<=[^\\\\\\\\])\\\\\\\\(?=[^\\\\\\\\\\\\\\\"\\\\s])|(\\\\\\\\(?=[^\\\\\\\"]))|((?<=[^\\\\\\\\][\\\\\\\\])\\\\\\\\(?=[\\\\\\\"]))\", RegexOptions.Compiled);",
"score": 0.7579749822616577
},
{
"filename": "Microsoft.Build.Utilities/CanonicalTrackedInputFiles.cs",
"retrieved_chunk": " if (text3[0] == '#' || text3[0] == '^')\n {\n break;\n }\n if (dictionary.ContainsKey(text3))\n {\n if (!DependencyTable.TryGetValue(text3, out value))\n {\n value = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { text3, null } };\n DependencyTable.Add(text3, value);",
"score": 0.7569394111633301
}
] | csharp | DependencyTableCacheEntry> DependencyTable { |
using System.Collections.Generic;
using GodotLauncher;
using Newtonsoft.Json;
public static class DataBuilder
{
public static Dictionary<string, InstallerEntryData> BuildInstallerData()
{
var json = FileHelper.ReadAllText("res://Data/installers.json");
var entries = LoadInstallerData(json);
return entries;
}
public static Dictionary<string, InstallerEntryData> LoadInstallerData(string json)
{
if (json == null) return new Dictionary<string, InstallerEntryData>();
var entries = JsonConvert.DeserializeObject<InstallerEntryData[]>(json);
var entriesDict = new Dictionary<string, InstallerEntryData>();
if (entries == null) return entriesDict;
foreach (var entry in entries)
{
entriesDict[entry.VersionKey] = entry;
}
return entriesDict;
}
public static string GetProjectListJson(List< | ProjectEntryData> projects)
{ |
return JsonConvert.SerializeObject(projects);
}
public static List<ProjectEntryData> LoadProjectListFromJson(string json)
{
return JsonConvert.DeserializeObject<List<ProjectEntryData>>(json);
}
public static string GetConfigJson(Config config)
{
return JsonConvert.SerializeObject(config);
}
public static Config LoadConfigFromJson(string json)
{
return JsonConvert.DeserializeObject<Config>(json);
}
}
| godot-project/Scripts/DataManagement/DataBuilder.cs | NathanWarden-ready-to-launch-58eba6d | [
{
"filename": "godot-project/Scripts/DataManagement/LauncherManager.cs",
"retrieved_chunk": "\t\t\tvar results = new List<InstallerEntryData>();\n\t\t\tforeach (var entry in installerEntries.Values)\n\t\t\t{\n\t\t\t\tbool installerExists = DataPaths.ExecutableExists(entry);\n\t\t\t\tif (installerExists) results.Add(entry);\n\t\t\t}\n\t\t\treturn results;\n\t\t}\n\t\tvoid BuildLists(bool showNewInstallers)\n\t\t{",
"score": 0.7788971662521362
},
{
"filename": "godot-project/Scripts/DataManagement/LauncherManager.cs",
"retrieved_chunk": "\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tvoid _onProjectVersionChanged(string path, string versionKey)\n\t\t{\n\t\t\tforeach (var entry in projectEntries)\n\t\t\t{\n\t\t\t\tif (entry.path.Equals(path))\n\t\t\t\t{\n\t\t\t\t\tentry.versionKey = versionKey;",
"score": 0.7766251564025879
},
{
"filename": "godot-project/Scripts/DataManagement/LauncherManager.cs",
"retrieved_chunk": "\t\t\t\tif (installerEntries.TryGetValue(entry.versionKey, out var installer))\n\t\t\t\t{\n\t\t\t\t\tversion = installer.version;\n\t\t\t\t\tbuildType = installer.BuildType;\n\t\t\t\t}\n\t\t\t\tprojectsEntriesNode.Call(\"_add_project_button\", entry.path, version, buildType, false, installerKeys, installerNames);\n\t\t\t}\n\t\t}\n\t\tList<InstallerEntryData> GetInstalledVersions()\n\t\t{",
"score": 0.7573049664497375
},
{
"filename": "godot-project/Scripts/DataManagement/LauncherManager.cs",
"retrieved_chunk": "\t\tvoid _onRunProject(string path)\n\t\t{\n\t\t\tLaunchProject(path, true);\n\t\t}\n\t\tvoid LaunchProject(string path, bool run)\n\t\t{\n\t\t\tfor (int i = 0; i < projectEntries.Count; i++)\n\t\t\t{\n\t\t\t\tif (projectEntries[i].path.Equals(path) && installerEntries.TryGetValue(projectEntries[i].versionKey, out var entry))\n\t\t\t\t{",
"score": 0.7516182661056519
},
{
"filename": "godot-project/Scripts/DataManagement/LauncherManager.cs",
"retrieved_chunk": "\t\t\t\tInstallVersion(versionKey);\n\t\t\t}\n\t\t\tSaveProjectsList();\n\t\t\tBuildProjectsList();\n\t\t}\n\t\tvoid SaveConfig()\n\t\t{\n\t\t\tvar json = DataBuilder.GetConfigJson(config);\n\t\t\tDataPaths.WriteFile(ConfigFileName, json);\n\t\t}",
"score": 0.7320493459701538
}
] | csharp | ProjectEntryData> projects)
{ |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using QuestSystem.SaveSystem;
using System.Linq;
namespace QuestSystem
{
[CreateAssetMenu(fileName = "New Quest", menuName = "QuestSystem/QuestLog")]
[System.Serializable]
public class QuestLog : ScriptableObject
{
public List<Quest> curentQuests = new List<Quest>();
public List<Quest> doneQuest = new List<Quest>();
public List<Quest> failedQuest = new List<Quest>();
public int businessDay;
public bool IsCurrent( | Quest q) => curentQuests.Contains(q); |
public bool IsDoned(Quest q) => doneQuest.Contains(q);
public bool IsFailed(Quest q) => failedQuest.Contains(q);
public void LoadUpdate(QuestLogSaveData qls)
{
//Coger el dia
businessDay = qls.dia;
//Actualizar currents
curentQuests = new List<Quest>();
foreach (QuestSaveData qs in qls.currentQuestSave)
{
Quest q = Resources.Load(QuestConstants.MISIONS_NAME + "/" + qs.name + "/" + qs.name) as Quest;
q.state = qs.states;
q.AdvanceToCurrentNode();
q.nodeActual.nodeObjectives = qs.actualNodeData.objectives;
curentQuests.Add(q);
}
//Done i failed add
doneQuest = new List<Quest>();
foreach (QuestSaveData qs in qls.doneQuestSave)
{
Quest q = Resources.Load(QuestConstants.MISIONS_NAME + "/" + qs.name + "/" + qs.name) as Quest;
doneQuest.Add(q);
}
failedQuest = new List<Quest>();
foreach (QuestSaveData qs in qls.failedQuestSave)
{
Quest q = Resources.Load(QuestConstants.MISIONS_NAME + "/" + qs.name + "/" + qs.name) as Quest;
failedQuest.Add(q);
}
}
public void RemoveQuest(Quest q)
{
if (IsCurrent(q))
curentQuests.Remove(q);
else if (IsDoned(q))
doneQuest.Remove(q);
else if (IsFailed(q))
failedQuest.Remove(q);
}
public void ResetAllQuest()
{
List<Quest> quests = curentQuests.Concat(doneQuest).Concat(failedQuest).ToList();
foreach (Quest q in quests)
{
q.Reset();
RemoveQuest(q);
}
}
}
} | Runtime/QuestLog.cs | lluispalerm-QuestSystem-cd836cc | [
{
"filename": "Runtime/SaveData/QuestLogSaveDataSurrogate.cs",
"retrieved_chunk": " public List<QuestSaveData> currentQuestSave;\n public List<QuestSaveData> doneQuestSave;\n public List<QuestSaveData> failedQuestSave;\n public int dia;\n public QuestLogSaveData(QuestLog ql)\n {\n //Manage current quest\n currentQuestSave = new List<QuestSaveData>();\n doneQuestSave = new List<QuestSaveData>();\n failedQuestSave = new List<QuestSaveData>();",
"score": 0.8254202604293823
},
{
"filename": "Runtime/QuestManager.cs",
"retrieved_chunk": " misionLog.curentQuests.Add(q);\n }\n public bool IsMisionInLog(Quest q)\n {\n return misionLog.IsCurrent(q) || misionLog.IsDoned(q) || misionLog.IsFailed(q);\n }\n public bool IsCurrent(Quest q) => misionLog.IsCurrent(q);\n public bool IsDoned(Quest q) => misionLog.IsDoned(q);\n public bool IsFailed(Quest q) => misionLog.IsFailed(q);\n public void DonearQuest(Quest q)",
"score": 0.8143312335014343
},
{
"filename": "Runtime/NodeQuest.cs",
"retrieved_chunk": "using System.Collections;\nusing System.Collections.Generic;\nusing UnityEngine;\nnamespace QuestSystem\n{\n [CreateAssetMenu(fileName = \"New NodeQuest\", menuName = \"QuestSystem/NodeQuest\")]\n [System.Serializable]\n public class NodeQuest : ScriptableObject\n {\n public List<NodeQuest> nextNode = new List<NodeQuest>();",
"score": 0.791602373123169
},
{
"filename": "Editor/GraphEditor/QuestGraphEditor.cs",
"retrieved_chunk": "{\n public class QuestGraphEditor : GraphViewEditorWindow\n {\n public static Quest questForGraph;\n private QuestGraphView _questGraph;\n private bool mouseClicked;\n [MenuItem(\"Tools/QuestGraph\")]\n public static void OpenQuestGraphWindow()\n {\n questForGraph = null;",
"score": 0.7837498188018799
},
{
"filename": "Runtime/QuestGiver.cs",
"retrieved_chunk": "using System.Collections;\nusing System.Collections.Generic;\nusing UnityEngine;\nnamespace QuestSystem\n{\n public class QuestGiver : MonoBehaviour , IQuestInteraction\n {\n public Quest questToGive;\n public TextAsset extraText;\n private bool ableToGive = false;",
"score": 0.7746410369873047
}
] | csharp | Quest q) => curentQuests.Contains(q); |
using Microsoft.AspNetCore.Mvc;
using WebApi.Configurations;
using WebApi.Extensions;
using WebApi.Models;
namespace WebApi.Services
{
public interface IValidationService
{
HeaderValidationResult<T> ValidateHeaders<T>(IHeaderDictionary requestHeaders) where T : ApiRequestHeaders;
QueryValidationResult<T> ValidateQueries<T>(T requestQueries) where T : ApiRequestQueries;
PayloadValidationResult<T> | ValidatePayload<T>(T requestPayload) where T : ApiPayload; |
}
public class ValidationService : IValidationService
{
private readonly AuthSettings _settings;
public ValidationService(AuthSettings settings)
{
this._settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public HeaderValidationResult<T> ValidateHeaders<T>(IHeaderDictionary requestHeaders) where T : ApiRequestHeaders
{
var headers = requestHeaders.ToObject<T>();
var result = new HeaderValidationResult<T>() { Headers = headers };
#if !DEBUG
var apiKey = headers.ApiKey;
if (string.IsNullOrWhiteSpace(apiKey) == true)
{
var error = new ErrorResponse() { Message = "Invalid API Key" };
result.ActionResult = new UnauthorizedObjectResult(error);
return result;
}
if (apiKey != this._settings.ApiKey)
{
var error = new ErrorResponse() { Message = "Invalid API Key" };
result.ActionResult = new UnauthorizedObjectResult(error);
return result;
}
#endif
if (headers is not GitHubApiRequestHeaders)
{
result.Validated = true;
return result;
}
var gitHubToken = (headers as GitHubApiRequestHeaders).GitHubToken;
if (string.IsNullOrWhiteSpace(gitHubToken) == true)
{
var error = new ErrorResponse() { Message = "Invalid GitHub Token" };
result.ActionResult = new ObjectResult(error) { StatusCode = StatusCodes.Status403Forbidden };
return result;
}
result.Validated = true;
return result;
}
public QueryValidationResult<T> ValidateQueries<T>(T requestQueries) where T : ApiRequestQueries
{
var result = new QueryValidationResult<T>() { Queries = requestQueries };
if (requestQueries is not GitHubApiRequestQueries)
{
result.Validated = true;
return result;
}
var queries = requestQueries as GitHubApiRequestQueries;
if (string.IsNullOrWhiteSpace(queries.User))
{
var error = new ErrorResponse() { Message = "No GitHub details found" };
result.ActionResult = new ObjectResult(error) { StatusCode = StatusCodes.Status404NotFound };
return result;
}
if (string.IsNullOrWhiteSpace(queries.Repository))
{
var error = new ErrorResponse() { Message = "No GitHub details found" };
result.ActionResult = new ObjectResult(error) { StatusCode = StatusCodes.Status404NotFound };
return result;
}
result.Validated = true;
return result;
}
public PayloadValidationResult<T> ValidatePayload<T>(T requestPayload) where T : ApiPayload
{
var result = new PayloadValidationResult<T>() { Payload = requestPayload };
if (requestPayload is not ChatCompletionRequest)
{
result.Validated = true;
return result;
}
var payload = requestPayload as ChatCompletionRequest;
if (string.IsNullOrWhiteSpace(payload.Prompt))
{
var error = new ErrorResponse() { Message = "No payload found" };
result.ActionResult = new ObjectResult(error) { StatusCode = StatusCodes.Status400BadRequest };
return result;
}
result.Validated = true;
return result;
}
}
} | src/IssueSummaryApi/Services/ValidationService.cs | Azure-Samples-vs-apim-cuscon-powerfx-500a170 | [
{
"filename": "src/IssueSummaryApi/Extensions/DictionaryExtensions.cs",
"retrieved_chunk": "using WebApi.Models;\nnamespace WebApi.Extensions\n{\n public static class DictionaryExtensions\n {\n public static T ToObject<T>(this IHeaderDictionary headers) where T : ApiRequestHeaders\n {\n var result = Activator.CreateInstance<T>();\n foreach (var header in headers)\n {",
"score": 0.8109170198440552
},
{
"filename": "src/IssueSummaryApi/Services/OpenAIService.cs",
"retrieved_chunk": "using WebApi.Models;\nusing WebApi.Helpers;\nnamespace WebApi.Services\n{\n public interface IOpenAIService\n {\n Task<ChatCompletionResponse> GetChatCompletionAsync(string prompt);\n }\n public class OpenAIService : IOpenAIService\n {",
"score": 0.7656828165054321
},
{
"filename": "src/IssueSummaryApi/Models/HeaderValidationResult.cs",
"retrieved_chunk": "using Microsoft.AspNetCore.Mvc;\nnamespace WebApi.Models\n{\n public class HeaderValidationResult<T> where T : ApiRequestHeaders\n {\n public virtual T? Headers { get; set; }\n public virtual bool Validated { get; set; }\n public virtual IActionResult? ActionResult { get; set; }\n }\n}",
"score": 0.7644941806793213
},
{
"filename": "src/IssueSummaryApi/Controllers/GitHubController.cs",
"retrieved_chunk": " [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status401Unauthorized)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status403Forbidden)]\n public async Task<IActionResult> GetIssueSummary(int id, [FromQuery] GitHubApiRequestQueries req)\n {\n var validation = this._validation.ValidateHeaders<GitHubApiRequestHeaders>(this.Request.Headers);\n if (validation.Validated != true)\n {\n return await Task.FromResult(validation.ActionResult);\n }\n var qvr = this._validation.ValidateQueries(req);",
"score": 0.7643238306045532
},
{
"filename": "src/IssueSummaryApi/Models/QueryValidationResult.cs",
"retrieved_chunk": "using Microsoft.AspNetCore.Mvc;\nnamespace WebApi.Models\n{\n public class QueryValidationResult<T> where T : ApiRequestQueries\n {\n public virtual T? Queries { get; set; }\n public virtual bool Validated { get; set; }\n public virtual IActionResult? ActionResult { get; set; }\n }\n}",
"score": 0.7614206075668335
}
] | csharp | ValidatePayload<T>(T requestPayload) where T : ApiPayload; |
using HarmonyLib;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using UnityEngine;
namespace Ultrapain.Patches
{
public class OrbitalStrikeFlag : MonoBehaviour
{
public CoinChainList chainList;
public bool isOrbitalRay = false;
public bool exploded = false;
public float activasionDistance;
}
public class Coin_Start
{
static void Postfix(Coin __instance)
{
__instance.gameObject.AddComponent<OrbitalStrikeFlag>();
}
}
public class CoinChainList : MonoBehaviour
{
public List< | Coin> chainList = new List<Coin>(); |
public bool isOrbitalStrike = false;
public float activasionDistance;
}
class Punch_BlastCheck
{
[HarmonyBefore(new string[] { "tempy.fastpunch" })]
static bool Prefix(Punch __instance)
{
__instance.blastWave = GameObject.Instantiate(Plugin.explosionWaveKnuckleblaster, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.blastWave.AddComponent<OrbitalStrikeFlag>();
return true;
}
[HarmonyBefore(new string[] { "tempy.fastpunch" })]
static void Postfix(Punch __instance)
{
GameObject.Destroy(__instance.blastWave);
__instance.blastWave = Plugin.explosionWaveKnuckleblaster;
}
}
class Explosion_Collide
{
static bool Prefix(Explosion __instance, Collider __0, List<Collider> ___hitColliders)
{
if (___hitColliders.Contains(__0)/* || __instance.transform.parent.GetComponent<OrbitalStrikeFlag>() == null*/)
return true;
Coin coin = __0.GetComponent<Coin>();
if (coin != null)
{
OrbitalStrikeFlag flag = coin.GetComponent<OrbitalStrikeFlag>();
if(flag == null)
{
coin.gameObject.AddComponent<OrbitalStrikeFlag>();
Debug.Log("Added orbital strike flag");
}
}
return true;
}
}
class Coin_DelayedReflectRevolver
{
static void Postfix(Coin __instance, GameObject ___altBeam)
{
CoinChainList flag = null;
OrbitalStrikeFlag orbitalBeamFlag = null;
if (___altBeam != null)
{
orbitalBeamFlag = ___altBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalBeamFlag == null)
{
orbitalBeamFlag = ___altBeam.AddComponent<OrbitalStrikeFlag>();
GameObject obj = new GameObject();
obj.AddComponent<RemoveOnTime>().time = 5f;
flag = obj.AddComponent<CoinChainList>();
orbitalBeamFlag.chainList = flag;
}
else
flag = orbitalBeamFlag.chainList;
}
else
{
if (__instance.ccc == null)
{
GameObject obj = new GameObject();
__instance.ccc = obj.AddComponent<CoinChainCache>();
obj.AddComponent<RemoveOnTime>().time = 5f;
}
flag = __instance.ccc.gameObject.GetComponent<CoinChainList>();
if(flag == null)
flag = __instance.ccc.gameObject.AddComponent<CoinChainList>();
}
if (flag == null)
return;
if (!flag.isOrbitalStrike && flag.chainList.Count != 0 && __instance.GetComponent<OrbitalStrikeFlag>() != null)
{
Coin lastCoin = flag.chainList.LastOrDefault();
float distance = Vector3.Distance(__instance.transform.position, lastCoin.transform.position);
if (distance >= ConfigManager.orbStrikeMinDistance.value)
{
flag.isOrbitalStrike = true;
flag.activasionDistance = distance;
if (orbitalBeamFlag != null)
{
orbitalBeamFlag.isOrbitalRay = true;
orbitalBeamFlag.activasionDistance = distance;
}
Debug.Log("Coin valid for orbital strike");
}
}
if (flag.chainList.Count == 0 || flag.chainList.LastOrDefault() != __instance)
flag.chainList.Add(__instance);
}
}
class Coin_ReflectRevolver
{
public static bool coinIsShooting = false;
public static Coin shootingCoin = null;
public static GameObject shootingAltBeam;
public static float lastCoinTime = 0;
static bool Prefix(Coin __instance, GameObject ___altBeam)
{
coinIsShooting = true;
shootingCoin = __instance;
lastCoinTime = Time.time;
shootingAltBeam = ___altBeam;
return true;
}
static void Postfix(Coin __instance)
{
coinIsShooting = false;
}
}
class RevolverBeam_Start
{
static bool Prefix(RevolverBeam __instance)
{
OrbitalStrikeFlag flag = __instance.GetComponent<OrbitalStrikeFlag>();
if (flag != null && flag.isOrbitalRay)
{
RevolverBeam_ExecuteHits.orbitalBeam = __instance;
RevolverBeam_ExecuteHits.orbitalBeamFlag = flag;
}
return true;
}
}
class RevolverBeam_ExecuteHits
{
public static bool isOrbitalRay = false;
public static RevolverBeam orbitalBeam = null;
public static OrbitalStrikeFlag orbitalBeamFlag = null;
static bool Prefix(RevolverBeam __instance)
{
OrbitalStrikeFlag flag = __instance.GetComponent<OrbitalStrikeFlag>();
if (flag != null && flag.isOrbitalRay)
{
isOrbitalRay = true;
orbitalBeam = __instance;
orbitalBeamFlag = flag;
}
return true;
}
static void Postfix()
{
isOrbitalRay = false;
}
}
class OrbitalExplosionInfo : MonoBehaviour
{
public bool active = true;
public string id;
public int points;
}
class Grenade_Explode
{
class StateInfo
{
public bool state = false;
public string id;
public int points;
public GameObject templateExplosion;
}
static bool Prefix(Grenade __instance, ref float __3, out StateInfo __state,
bool __1, bool __2)
{
__state = new StateInfo();
if((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null) || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f))
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike)
{
if (__1)
{
__state.templateExplosion = GameObject.Instantiate(__instance.harmlessExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.harmlessExplosion = __state.templateExplosion;
}
else if (__2)
{
__state.templateExplosion = GameObject.Instantiate(__instance.superExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.superExplosion = __state.templateExplosion;
}
else
{
__state.templateExplosion = GameObject.Instantiate(__instance.explosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.explosion = __state.templateExplosion;
}
OrbitalExplosionInfo info = __state.templateExplosion.AddComponent<OrbitalExplosionInfo>();
info.id = "";
__state.state = true;
float damageMulti = 1f;
float sizeMulti = 1f;
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if (ConfigManager.orbStrikeRevolverChargedGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverChargedStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverChargedStylePoint.value;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if (ConfigManager.orbStrikeElectricCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeElectricCannonExplosionDamage.value;
sizeMulti += ConfigManager.orbStrikeElectricCannonExplosionSize.value;
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
if (ConfigManager.orbStrikeMaliciousCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
}
}
else
__state.state = false;
}
else
__state.state = false;
if(sizeMulti != 1 || damageMulti != 1)
foreach(Explosion exp in __state.templateExplosion.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.damage = (int)(exp.damage * damageMulti);
}
Debug.Log("Applied orbital strike bonus");
}
}
return true;
}
static void Postfix(Grenade __instance, StateInfo __state)
{
if (__state.templateExplosion != null)
GameObject.Destroy(__state.templateExplosion);
if (!__state.state)
return;
}
}
class Cannonball_Explode
{
static bool Prefix(Cannonball __instance, GameObject ___interruptionExplosion, ref GameObject ___breakEffect)
{
if ((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null) || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f))
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike && ___interruptionExplosion != null)
{
float damageMulti = 1f;
float sizeMulti = 1f;
GameObject explosion = GameObject.Instantiate<GameObject>(___interruptionExplosion, __instance.transform.position, Quaternion.identity);
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = "";
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if (ConfigManager.orbStrikeRevolverChargedGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverChargedStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverChargedStylePoint.value;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if (ConfigManager.orbStrikeElectricCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeElectricCannonExplosionDamage.value;
sizeMulti += ConfigManager.orbStrikeElectricCannonExplosionSize.value;
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
if (ConfigManager.orbStrikeMaliciousCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
}
}
}
if (sizeMulti != 1 || damageMulti != 1)
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.damage = (int)(exp.damage * damageMulti);
}
if (MonoSingleton<PrefsManager>.Instance.GetBoolLocal("simpleExplosions", false))
{
___breakEffect = null;
}
__instance.Break();
return false;
}
}
return true;
}
}
class Explosion_CollideOrbital
{
static bool Prefix(Explosion __instance, Collider __0)
{
OrbitalExplosionInfo flag = __instance.transform.parent.GetComponent<OrbitalExplosionInfo>();
if (flag == null || !flag.active)
return true;
if ( __0.gameObject.tag != "Player" && (__0.gameObject.layer == 10 || __0.gameObject.layer == 11)
&& __instance.canHit != AffectedSubjects.PlayerOnly)
{
EnemyIdentifierIdentifier componentInParent = __0.GetComponentInParent<EnemyIdentifierIdentifier>();
if (componentInParent != null && componentInParent.eid != null && !componentInParent.eid.blessed/* && !componentInParent.eid.dead*/)
{
flag.active = false;
if(flag.id != "")
StyleHUD.Instance.AddPoints(flag.points, flag.id);
}
}
return true;
}
}
class EnemyIdentifier_DeliverDamage
{
static Coin lastExplosiveCoin = null;
class StateInfo
{
public bool canPostStyle = false;
public OrbitalExplosionInfo info = null;
}
static bool Prefix(EnemyIdentifier __instance, out StateInfo __state, Vector3 __2, ref float __3)
{
//if (Coin_ReflectRevolver.shootingCoin == lastExplosiveCoin)
// return true;
__state = new StateInfo();
bool causeExplosion = false;
if (__instance.dead)
return true;
if ((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null)/* || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f)*/)
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike)
{
causeExplosion = true;
}
}
else if (RevolverBeam_ExecuteHits.isOrbitalRay && RevolverBeam_ExecuteHits.orbitalBeam != null)
{
if (RevolverBeam_ExecuteHits.orbitalBeamFlag != null && !RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded)
{
causeExplosion = true;
}
}
if(causeExplosion)
{
__state.canPostStyle = true;
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if(ConfigManager.orbStrikeRevolverExplosion.value)
{
GameObject explosion = GameObject.Instantiate(Plugin.explosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeRevolverExplosionDamage.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
__state.info = info;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if(ConfigManager.orbStrikeRevolverChargedInsignia.value)
{
GameObject insignia = GameObject.Instantiate(Plugin.virtueInsignia, /*__instance.transform.position*/__2, Quaternion.identity);
// This is required for ff override to detect this insignia as non ff attack
insignia.gameObject.name = "PlayerSpawned";
float horizontalSize = ConfigManager.orbStrikeRevolverChargedInsigniaSize.value;
insignia.transform.localScale = new Vector3(horizontalSize, insignia.transform.localScale.y, horizontalSize);
VirtueInsignia comp = insignia.GetComponent<VirtueInsignia>();
comp.windUpSpeedMultiplier = ConfigManager.orbStrikeRevolverChargedInsigniaDelayBoost.value;
comp.damage = ConfigManager.orbStrikeRevolverChargedInsigniaDamage.value;
comp.predictive = false;
comp.hadParent = false;
comp.noTracking = true;
StyleHUD.Instance.AddPoints(ConfigManager.orbStrikeRevolverChargedStylePoint.value, ConfigManager.orbStrikeRevolverChargedStyleText.guid);
__state.canPostStyle = false;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverExplosion.value)
{
GameObject explosion = GameObject.Instantiate(Plugin.explosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeRevolverExplosionDamage.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
__state.info = info;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if(ConfigManager.orbStrikeElectricCannonExplosion.value)
{
GameObject lighning = GameObject.Instantiate(Plugin.lightningStrikeExplosive, /*__instance.gameObject.transform.position*/ __2, Quaternion.identity);
foreach (Explosion exp in lighning.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
if (exp.damage == 0)
exp.maxSize /= 2;
exp.maxSize *= ConfigManager.orbStrikeElectricCannonExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeElectricCannonExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeElectricCannonExplosionDamage.value);
exp.canHit = AffectedSubjects.All;
}
OrbitalExplosionInfo info = lighning.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
__state.info = info;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
// UNUSED
causeExplosion = false;
}
// MALICIOUS BEAM
else if (beam.beamType == BeamType.MaliciousFace)
{
GameObject explosion = GameObject.Instantiate(Plugin.sisyphiusPrimeExplosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.maliciousChargebackExplosionSizeMultiplier.value;
exp.speed *= ConfigManager.maliciousChargebackExplosionSizeMultiplier.value;
exp.damage = (int)(exp.damage * ConfigManager.maliciousChargebackExplosionDamageMultiplier.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.maliciousChargebackStyleText.guid;
info.points = ConfigManager.maliciousChargebackStylePoint.value;
__state.info = info;
}
// SENTRY BEAM
else if (beam.beamType == BeamType.Enemy)
{
StyleHUD.Instance.AddPoints(ConfigManager.sentryChargebackStylePoint.value, ConfigManager.sentryChargebackStyleText.formattedString);
if (ConfigManager.sentryChargebackExtraBeamCount.value > 0)
{
List<Tuple<EnemyIdentifier, float>> enemies = UnityUtils.GetClosestEnemies(__2, ConfigManager.sentryChargebackExtraBeamCount.value, UnityUtils.doNotCollideWithPlayerValidator);
foreach (Tuple<EnemyIdentifier, float> enemy in enemies)
{
RevolverBeam newBeam = GameObject.Instantiate(beam, beam.transform.position, Quaternion.identity);
newBeam.hitEids.Add(__instance);
newBeam.transform.LookAt(enemy.Item1.transform);
GameObject.Destroy(newBeam.GetComponent<OrbitalStrikeFlag>());
}
}
RevolverBeam_ExecuteHits.isOrbitalRay = false;
}
}
if (causeExplosion && RevolverBeam_ExecuteHits.orbitalBeamFlag != null)
RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded = true;
Debug.Log("Applied orbital strike explosion");
}
return true;
}
static void Postfix(EnemyIdentifier __instance, StateInfo __state)
{
if(__state.canPostStyle && __instance.dead && __state.info != null)
{
__state.info.active = false;
if (__state.info.id != "")
StyleHUD.Instance.AddPoints(__state.info.points, __state.info.id);
}
}
}
class RevolverBeam_HitSomething
{
static bool Prefix(RevolverBeam __instance, out GameObject __state)
{
__state = null;
if (RevolverBeam_ExecuteHits.orbitalBeam == null)
return true;
if (__instance.beamType != BeamType.Railgun)
return true;
if (__instance.hitAmount != 1)
return true;
if (RevolverBeam_ExecuteHits.orbitalBeam.GetInstanceID() == __instance.GetInstanceID())
{
if (!RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded && ConfigManager.orbStrikeMaliciousCannonExplosion.value)
{
Debug.Log("MALICIOUS EXPLOSION EXTRA SIZE");
GameObject tempExp = GameObject.Instantiate(__instance.hitParticle, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
foreach (Explosion exp in tempExp.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= ConfigManager.orbStrikeMaliciousCannonExplosionSizeMultiplier.value;
exp.speed *= ConfigManager.orbStrikeMaliciousCannonExplosionSizeMultiplier.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeMaliciousCannonExplosionDamageMultiplier.value);
}
__instance.hitParticle = tempExp;
OrbitalExplosionInfo info = tempExp.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded = true;
}
Debug.Log("Already exploded");
}
else
Debug.Log("Not the same instance");
return true;
}
static void Postfix(RevolverBeam __instance, GameObject __state)
{
if (__state != null)
GameObject.Destroy(__state);
}
}
}
| Ultrapain/Patches/OrbitalStrike.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Cerberus.cs",
"retrieved_chunk": " }\n }\n class StatueBoss_Start_Patch\n {\n static void Postfix(StatueBoss __instance)\n {\n __instance.gameObject.AddComponent<CerberusFlag>();\n }\n }\n}",
"score": 0.8503948450088501
},
{
"filename": "Ultrapain/Patches/SomethingWicked.cs",
"retrieved_chunk": " {\n static void Postfix(Wicked __instance)\n {\n SomethingWickedFlag flag = __instance.gameObject.AddComponent<SomethingWickedFlag>();\n }\n }\n class SomethingWicked_GetHit\n {\n static void Postfix(Wicked __instance)\n {",
"score": 0.8284225463867188
},
{
"filename": "Ultrapain/Patches/Stalker.cs",
"retrieved_chunk": " }\n }\n __instance.gameObject.SetActive(false);\n Object.Destroy(__instance.gameObject);\n return false;\n }\n }\n public class SandificationZone_Enter_Patch\n {\n static void Postfix(SandificationZone __instance, Collider __0)",
"score": 0.8228095769882202
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " }\n }\n return true;\n }\n }\n class LeviathanTail_Start\n {\n static void Postfix(LeviathanTail __instance)\n {\n __instance.gameObject.AddComponent<LeviathanTail_Flag>();",
"score": 0.8185679912567139
},
{
"filename": "Ultrapain/Patches/MinosPrime.cs",
"retrieved_chunk": " }\n class MinosPrimeFlag : MonoBehaviour\n {\n void Start()\n {\n }\n public void ComboExplosion()\n {\n GameObject explosion = Instantiate(Plugin.lightningStrikeExplosive, transform.position, Quaternion.identity);\n foreach(Explosion e in explosion.GetComponentsInChildren<Explosion>())",
"score": 0.815924882888794
}
] | csharp | Coin> chainList = new List<Coin>(); |
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using SQLServerCoverage.Gateway;
using SQLServerCoverage.Source;
using SQLServerCoverage.Trace;
namespace SQLServerCoverage
{
public class CodeCoverage
{
private const int MAX_DISPATCH_LATENCY = 1000;
private readonly DatabaseGateway _database;
private readonly string _databaseName;
private readonly bool _debugger;
private readonly TraceControllerType _traceType;
private readonly List<string> _excludeFilter;
private readonly bool _logging;
private readonly SourceGateway _source;
private CoverageResult _result;
public const short TIMEOUT_EXPIRED = -2; //From TdsEnums
public SQLServerCoverageException Exception { get; private set; } = null;
public bool IsStarted { get; private set; } = false;
private TraceController _trace;
//This is to better support powershell and optional parameters
public CodeCoverage(string connectionString, string databaseName) : this(connectionString, databaseName, null, false, false, TraceControllerType.Default)
{
}
public CodeCoverage(string connectionString, string databaseName, string[] excludeFilter) : this(connectionString, databaseName, excludeFilter, false, false, TraceControllerType.Default)
{
}
public CodeCoverage(string connectionString, string databaseName, string[] excludeFilter, bool logging) : this(connectionString, databaseName, excludeFilter, logging, false, TraceControllerType.Default)
{
}
public CodeCoverage(string connectionString, string databaseName, string[] excludeFilter, bool logging, bool debugger) : this(connectionString, databaseName, excludeFilter, logging, debugger, TraceControllerType.Default)
{
}
public CodeCoverage(string connectionString, string databaseName, string[] excludeFilter, bool logging, bool debugger, TraceControllerType traceType)
{
if (debugger)
Debugger.Launch();
_databaseName = databaseName;
if (excludeFilter == null)
excludeFilter = new string[0];
_excludeFilter = excludeFilter.ToList();
_logging = logging;
_debugger = debugger;
_traceType = traceType;
_database = new DatabaseGateway(connectionString, databaseName);
_source = new DatabaseSourceGateway(_database);
}
public bool Start(int timeOut = 30)
{
Exception = null;
try
{
_database.TimeOut = timeOut;
_trace = new TraceControllerBuilder().GetTraceController(_database, _databaseName, _traceType);
_trace.Start();
IsStarted = true;
return true;
}
catch (Exception ex)
{
Debug("Error starting trace: {0}", ex);
Exception = new SQLServerCoverageException("SQL Cover failed to start.", ex);
IsStarted = false;
return false;
}
}
private List<string> StopInternal()
{
var events = _trace.ReadTrace();
_trace.Stop();
_trace.Drop();
return events;
}
public | CoverageResult Stop()
{ |
if (!IsStarted)
throw new SQLServerCoverageException("SQL Cover was not started, or did not start correctly.");
IsStarted = false;
WaitForTraceMaxLatency();
var results = StopInternal();
GenerateResults(_excludeFilter, results, new List<string>(), "SQLServerCoverage result of running external process");
return _result;
}
private void Debug(string message, params object[] args)
{
if (_logging)
Console.WriteLine(message, args);
}
public CoverageResult Cover(string command, int timeOut = 30)
{
Debug("Starting Code Coverage");
_database.TimeOut = timeOut;
if (!Start())
{
throw new SQLServerCoverageException("Unable to start the trace - errors are recorded in the debug output");
}
Debug("Executing Command: {0}", command);
var sqlExceptions = new List<string>();
try
{
_database.Execute(command, timeOut, true);
}
catch (System.Data.SqlClient.SqlException e)
{
if (e.Number == -2)
{
throw;
}
sqlExceptions.Add(e.Message);
}
catch (Exception e)
{
Console.WriteLine("Exception running command: {0} - error: {1}", command, e.Message);
}
Debug("Executing Command: {0}...done", command);
WaitForTraceMaxLatency();
Debug("Stopping Code Coverage");
try
{
var rawEvents = StopInternal();
Debug("Getting Code Coverage Result");
GenerateResults(_excludeFilter, rawEvents, sqlExceptions, $"SQLServerCoverage result of running '{command}'");
Debug("Result generated");
}
catch (Exception e)
{
Console.Write(e.StackTrace);
throw new SQLServerCoverageException("Exception gathering the results", e);
}
return _result;
}
private static void WaitForTraceMaxLatency()
{
Thread.Sleep(MAX_DISPATCH_LATENCY);
}
private void GenerateResults(List<string> filter, List<string> xml, List<string> sqlExceptions, string commandDetail)
{
var batches = _source.GetBatches(filter);
_result = new CoverageResult(batches, xml, _databaseName, _database.DataSource, sqlExceptions, commandDetail);
}
public CoverageResult Results()
{
return _result;
}
}
} | src/SQLServerCoverageLib/CodeCoverage.cs | sayantandey-SQLServerCoverage-aea57e3 | [
{
"filename": "src/SQLServerCoverageLib/Trace/AzureTraceController.cs",
"retrieved_chunk": " {\n //stop is called from readtrace so we can read the data before closing it when using a ring buffer\n }\n public override List<string> ReadTrace()\n {\n StopInternal();\n return _events;\n }\n public override void Drop()\n {",
"score": 0.8403522968292236
},
{
"filename": "src/SQLServerCoverageLib/Trace/AzureTraceController.cs",
"retrieved_chunk": " }\n }\n public void StopInternal()\n {\n _stop = true;\n while (!_stopped)\n Thread.Sleep(1000);\n RunScript(StopTraceFormat, \"Error stopping the extended events trace, error: {0}\");\n }\n public override void Stop()",
"score": 0.8272726535797119
},
{
"filename": "src/SQLServerCoverageLib/Trace/SqlTraceController.cs",
"retrieved_chunk": " var events = new List<string>();\n foreach (DataRow row in data.Rows)\n {\n events.Add(row.ItemArray[0].ToString());\n }\n return events;\n }\n public override void Drop()\n {\n RunScript(DropTraceFormat, \"Error dropping the extended events trace, error: {0}\");",
"score": 0.8119657039642334
},
{
"filename": "src/SQLServerCoverageLib/Trace/SqlTraceController.cs",
"retrieved_chunk": " Create();\n RunScript(StartTraceFormat, \"Error starting the extended events trace, error: {0}\");\n }\n public override void Stop()\n {\n RunScript(StopTraceFormat, \"Error stopping the extended events trace, error: {0}\");\n }\n public override List<string> ReadTrace()\n {\n var data = Gateway.GetTraceRecords(string.Format(ReadTraceFormat, FileName));",
"score": 0.8090528845787048
},
{
"filename": "src/SQLServerCoverageLib/Trace/AzureTraceController.cs",
"retrieved_chunk": " private readonly List<string> _events = new List<string>();\n private bool _stop;\n private bool _stopped;\n private bool _stopping;\n public AzureTraceController(DatabaseGateway gateway, string databaseName) : base(gateway, databaseName)\n {\n }\n private void Create()\n {\n RunScript(CreateTrace, \"Error creating the extended events trace, error: {0}\");",
"score": 0.8062007427215576
}
] | csharp | CoverageResult Stop()
{ |
using HarmonyLib;
using UnityEngine;
namespace Ultrapain.Patches
{
class GrenadeParriedFlag : MonoBehaviour
{
public int parryCount = 1;
public bool registeredStyle = false;
public bool bigExplosionOverride = false;
public GameObject temporaryExplosion;
public GameObject temporaryBigExplosion;
public GameObject weapon;
public enum GrenadeType
{
Core,
Rocket,
}
public GrenadeType grenadeType;
}
class Punch_CheckForProjectile_Patch
{
static bool Prefix(Punch __instance, Transform __0, ref bool __result, ref bool ___hitSomething, Animator ___anim)
{
Grenade grn = __0.GetComponent<Grenade>();
if(grn != null)
{
if (grn.rocket && !ConfigManager.rocketBoostToggle.value)
return true;
if (!ConfigManager.grenadeBoostToggle.value)
return true;
MonoSingleton<TimeController>.Instance.ParryFlash();
___hitSomething = true;
grn.transform.LookAt(Camera.main.transform.position + Camera.main.transform.forward * 100.0f);
Rigidbody rb = grn.GetComponent<Rigidbody>();
rb.velocity = Vector3.zero;
rb.AddRelativeForce(Vector3.forward * Mathf.Max(Plugin.MinGrenadeParryVelocity, rb.velocity.magnitude), ForceMode.VelocityChange);
rb.velocity = grn.transform.forward * Mathf.Max(Plugin.MinGrenadeParryVelocity, rb.velocity.magnitude);
/*if (grn.rocket)
MonoSingleton<StyleHUD>.Instance.AddPoints(100, Plugin.StyleIDs.rocketBoost, MonoSingleton<GunControl>.Instance.currentWeapon, null);
else
MonoSingleton<StyleHUD>.Instance.AddPoints(100, Plugin.StyleIDs.fistfulOfNades, MonoSingleton<GunControl>.Instance.currentWeapon, null);
*/
GrenadeParriedFlag flag = grn.GetComponent<GrenadeParriedFlag>();
if (flag != null)
flag.parryCount += 1;
else
{
flag = grn.gameObject.AddComponent<GrenadeParriedFlag>();
flag.grenadeType = (grn.rocket) ? GrenadeParriedFlag.GrenadeType.Rocket : GrenadeParriedFlag.GrenadeType.Core;
flag.weapon = MonoSingleton<GunControl>.Instance.currentWeapon;
}
grn.rocketSpeed *= 1f + ConfigManager.rocketBoostSpeedMultiplierPerHit.value;
___anim.Play("Hook", 0, 0.065f);
__result = true;
return false;
}
return true;
}
}
class Grenade_Explode_Patch1
{
static bool Prefix(Grenade __instance, ref bool __2, ref bool __1, ref bool ___exploded)
{
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return true;
if (__instance.rocket)
{
bool rocketParried = flag != null;
bool rocketHitGround = __1;
flag.temporaryBigExplosion = GameObject.Instantiate(__instance.superExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.superExplosion = flag.temporaryBigExplosion;
foreach (Explosion e in __instance.superExplosion.GetComponentsInChildren<Explosion>())
{
e.speed *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
e.damage *= (int)(1f + ConfigManager.rocketBoostDamageMultiplierPerHit.value * flag.parryCount);
e.maxSize *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
}
flag.temporaryExplosion = GameObject.Instantiate(__instance.explosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.explosion = flag.temporaryExplosion;
if (rocketParried/* && rocketHitGround*/)
{
if(!rocketHitGround || ConfigManager.rocketBoostAlwaysExplodesToggle.value)
__1 = false;
foreach(Explosion e in (__2) ? flag.temporaryBigExplosion.GetComponentsInChildren<Explosion>() : flag.temporaryExplosion.GetComponentsInChildren<Explosion>())
{
GrenadeParriedFlag fFlag = e.gameObject.AddComponent<GrenadeParriedFlag>();
fFlag.weapon = flag.weapon;
fFlag.grenadeType = GrenadeParriedFlag.GrenadeType.Rocket;
fFlag.parryCount = flag.parryCount;
break;
}
}
foreach (Explosion e in __instance.explosion.GetComponentsInChildren<Explosion>())
{
e.speed *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
e.damage *= (int)(1f + ConfigManager.rocketBoostDamageMultiplierPerHit.value * flag.parryCount);
e.maxSize *= 1f + ConfigManager.rocketBoostSizeMultiplierPerHit.value * flag.parryCount;
}
}
else
{
if (flag != null/* && flag.bigExplosionOverride*/)
{
__2 = true;
GameObject explosion = GameObject.Instantiate(__instance.superExplosion);
foreach(Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.damage = (int)(exp.damage * ConfigManager.grenadeBoostDamageMultiplier.value);
exp.maxSize *= ConfigManager.grenadeBoostSizeMultiplier.value;
exp.speed *= ConfigManager.grenadeBoostSizeMultiplier.value;
}
__instance.superExplosion = explosion;
flag.temporaryBigExplosion = explosion;
}
}
return true;
}
static void Postfix(Grenade __instance, ref bool ___exploded)
{
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return;
if (__instance.rocket)
{
if (flag.temporaryExplosion != null)
{
GameObject.Destroy(flag.temporaryExplosion);
flag.temporaryExplosion = null;
}
if (flag.temporaryBigExplosion != null)
{
GameObject.Destroy(flag.temporaryBigExplosion);
flag.temporaryBigExplosion = null;
}
}
else
{
if (flag.temporaryBigExplosion != null)
{
GameObject.Destroy(flag.temporaryBigExplosion);
flag.temporaryBigExplosion = null;
}
}
}
}
class Grenade_Collision_Patch
{
static float lastTime = 0;
static bool Prefix( | Grenade __instance, Collider __0)
{ |
GrenadeParriedFlag flag = __instance.GetComponent<GrenadeParriedFlag>();
if (flag == null)
return true;
//if (!Plugin.ultrapainDifficulty || !ConfigManager.playerTweakToggle.value || !ConfigManager.grenadeBoostToggle.value)
// return true;
if (__0.gameObject.layer != 14 && __0.gameObject.layer != 20)
{
EnemyIdentifierIdentifier enemyIdentifierIdentifier;
if ((__0.gameObject.layer == 11 || __0.gameObject.layer == 10) && __0.TryGetComponent<EnemyIdentifierIdentifier>(out enemyIdentifierIdentifier) && enemyIdentifierIdentifier.eid)
{
if (enemyIdentifierIdentifier.eid.enemyType != EnemyType.MaliciousFace && flag.grenadeType == GrenadeParriedFlag.GrenadeType.Core && (Time.time - lastTime >= 0.25f || lastTime < 0))
{
lastTime = Time.time;
flag.bigExplosionOverride = true;
MonoSingleton<StyleHUD>.Instance.AddPoints(ConfigManager.grenadeBoostStylePoints.value, ConfigManager.grenadeBoostStyleText.guid, MonoSingleton<GunControl>.Instance.currentWeapon, null);
}
}
}
return true;
}
}
class Explosion_Collide_Patch
{
static float lastTime = 0;
static bool Prefix(Explosion __instance, Collider __0)
{
GrenadeParriedFlag flag = __instance.gameObject.GetComponent<GrenadeParriedFlag>();
if (flag == null || flag.registeredStyle)
return true;
if (!flag.registeredStyle && __0.gameObject.tag != "Player" && (__0.gameObject.layer == 10 || __0.gameObject.layer == 11)
&& __instance.canHit != AffectedSubjects.PlayerOnly)
{
EnemyIdentifierIdentifier componentInParent = __0.GetComponentInParent<EnemyIdentifierIdentifier>();
if(flag.grenadeType == GrenadeParriedFlag.GrenadeType.Rocket && componentInParent != null && componentInParent.eid != null && !componentInParent.eid.blessed && !componentInParent.eid.dead && (Time.time - lastTime >= 0.25f || lastTime < 0))
{
flag.registeredStyle = true;
lastTime = Time.time;
MonoSingleton<StyleHUD>.Instance.AddPoints(ConfigManager.rocketBoostStylePoints.value, ConfigManager.rocketBoostStyleText.guid, flag.weapon, null, flag.parryCount);
}
}
return true;
}
}
}
| Ultrapain/Patches/Parry.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/MaliciousFace.cs",
"retrieved_chunk": " flag.charging = false;\n }\n return true;\n }\n }\n class MaliciousFace_ShootProj_Patch\n {\n /*static bool Prefix(SpiderBody __instance, ref GameObject ___proj, out bool __state)\n {\n __state = false;",
"score": 0.8595656156539917
},
{
"filename": "Ultrapain/Patches/OrbitalStrike.cs",
"retrieved_chunk": " {\n public bool state = false;\n public string id;\n public int points;\n public GameObject templateExplosion;\n }\n static bool Prefix(Grenade __instance, ref float __3, out StateInfo __state,\n bool __1, bool __2)\n {\n __state = new StateInfo();",
"score": 0.8544814586639404
},
{
"filename": "Ultrapain/Patches/V2Second.cs",
"retrieved_chunk": " void PrepareAltFire()\n {\n }\n void AltFire()\n {\n }\n }\n class V2SecondUpdate\n {\n static bool Prefix(V2 __instance, ref int ___currentWeapon, ref Transform ___overrideTarget, ref Rigidbody ___overrideTargetRb, ref float ___shootCooldown,",
"score": 0.8536055684089661
},
{
"filename": "Ultrapain/Patches/Mindflayer.cs",
"retrieved_chunk": " //___eid.SpeedBuff();\n }\n }\n class Mindflayer_ShootProjectiles_Patch\n {\n public static float maxProjDistance = 5;\n public static float initialProjectileDistance = -1f;\n public static float distancePerProjShot = 0.2f;\n static bool Prefix(Mindflayer __instance, ref EnemyIdentifier ___eid, ref LayerMask ___environmentMask, ref bool ___enraged)\n {",
"score": 0.8528493046760559
},
{
"filename": "Ultrapain/Patches/Screwdriver.cs",
"retrieved_chunk": " {\n targetEids.Clear();\n }\n }\n }\n }\n class Harpoon_Start\n {\n static void Postfix(Harpoon __instance)\n {",
"score": 0.8498263955116272
}
] | csharp | Grenade __instance, Collider __0)
{ |
using HarmonyLib;
using UnityEngine;
namespace Ultrapain.Patches
{
class TurretFlag : MonoBehaviour
{
public int shootCountRemaining = ConfigManager.turretBurstFireCount.value;
}
class TurretStart
{
static void Postfix(Turret __instance)
{
__instance.gameObject.AddComponent<TurretFlag>();
}
}
class TurretShoot
{
static bool Prefix(Turret __instance, ref EnemyIdentifier ___eid, ref RevolverBeam ___beam, ref | Transform ___shootPoint,
ref float ___aimTime, ref float ___maxAimTime, ref float ___nextBeepTime, ref float ___flashTime)
{ |
TurretFlag flag = __instance.GetComponent<TurretFlag>();
if (flag == null)
return true;
if (flag.shootCountRemaining > 0)
{
RevolverBeam revolverBeam = GameObject.Instantiate<RevolverBeam>(___beam, new Vector3(__instance.transform.position.x, ___shootPoint.transform.position.y, __instance.transform.position.z), ___shootPoint.transform.rotation);
revolverBeam.alternateStartPoint = ___shootPoint.transform.position;
RevolverBeam revolverBeam2;
if (___eid.totalDamageModifier != 1f && revolverBeam.TryGetComponent<RevolverBeam>(out revolverBeam2))
{
revolverBeam2.damage *= ___eid.totalDamageModifier;
}
___nextBeepTime = 0;
___flashTime = 0;
___aimTime = ___maxAimTime - ConfigManager.turretBurstFireDelay.value;
if (___aimTime < 0)
___aimTime = 0;
flag.shootCountRemaining -= 1;
return false;
}
else
flag.shootCountRemaining = ConfigManager.turretBurstFireCount.value;
return true;
}
}
class TurretAim
{
static void Postfix(Turret __instance)
{
TurretFlag flag = __instance.GetComponent<TurretFlag>();
if (flag == null)
return;
flag.shootCountRemaining = ConfigManager.turretBurstFireCount.value;
}
}
}
| Ultrapain/Patches/Turret.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Mindflayer.cs",
"retrieved_chunk": " //___eid.SpeedBuff();\n }\n }\n class Mindflayer_ShootProjectiles_Patch\n {\n public static float maxProjDistance = 5;\n public static float initialProjectileDistance = -1f;\n public static float distancePerProjShot = 0.2f;\n static bool Prefix(Mindflayer __instance, ref EnemyIdentifier ___eid, ref LayerMask ___environmentMask, ref bool ___enraged)\n {",
"score": 0.8551724553108215
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " }\n return false;\n }\n }\n class Leviathan_ProjectileBurst\n {\n static bool Prefix(LeviathanHead __instance, Animator ___anim,\n ref int ___projectilesLeftInBurst, ref float ___projectileBurstCooldown, ref bool ___inAction)\n {\n if (!__instance.active)",
"score": 0.8531092405319214
},
{
"filename": "Ultrapain/Patches/Stray.cs",
"retrieved_chunk": " public static int projectileDamage = 10;\n public static int explosionDamage = 20;\n public static float coreSpeed = 110f;\n static void Postfix(ZombieProjectiles __instance, ref EnemyIdentifier ___eid, ref Animator ___anim, ref GameObject ___currentProjectile\n , ref NavMeshAgent ___nma, ref Zombie ___zmb)\n {\n if (___eid.enemyType != EnemyType.Stray)\n return;\n StrayFlag flag = __instance.gameObject.GetComponent<StrayFlag>();\n if (flag == null)",
"score": 0.8491692543029785
},
{
"filename": "Ultrapain/Patches/Mindflayer.cs",
"retrieved_chunk": " componentInChildren.sourceWeapon = __instance.gameObject;\n counter.shotsLeft -= 1;\n __instance.Invoke(\"ShootProjectiles\", ConfigManager.mindflayerShootDelay.value / ___eid.totalSpeedModifier);\n return false;\n }\n }\n class EnemyIdentifier_DeliverDamage_MF\n {\n static bool Prefix(EnemyIdentifier __instance, ref float __3, GameObject __6)\n {",
"score": 0.8484004735946655
},
{
"filename": "Ultrapain/Patches/Mindflayer.cs",
"retrieved_chunk": " }\n else\n patch.swingComboLeft = 2;*/\n }\n }\n class Mindflayer_MeleeTeleport_Patch\n {\n public static Vector3 deltaPosition = new Vector3(0, -10, 0);\n static bool Prefix(Mindflayer __instance, ref EnemyIdentifier ___eid, ref LayerMask ___environmentMask, ref bool ___goingLeft, ref Animator ___anim, ref bool ___enraged)\n {",
"score": 0.8466416001319885
}
] | csharp | Transform ___shootPoint,
ref float ___aimTime, ref float ___maxAimTime, ref float ___nextBeepTime, ref float ___flashTime)
{ |
using System;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Audio;
namespace Ultrapain.Patches
{
class DruidKnight_FullBurst
{
public static AudioMixer mixer;
public static float offset = 0.205f;
class StateInfo
{
public GameObject oldProj;
public GameObject tempProj;
}
static bool Prefix(Mandalore __instance, out StateInfo __state)
{
__state = new StateInfo() { oldProj = __instance.fullAutoProjectile };
GameObject obj = new GameObject();
obj.transform.position = __instance.transform.position;
AudioSource aud = obj.AddComponent<AudioSource>();
aud.playOnAwake = false;
aud.clip = Plugin.druidKnightFullAutoAud;
aud.time = offset;
aud.Play();
GameObject proj = GameObject.Instantiate(__instance.fullAutoProjectile, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
proj.GetComponent<AudioSource>().enabled = false;
__state.tempProj = __instance.fullAutoProjectile = proj;
return true;
}
static void Postfix( | Mandalore __instance, StateInfo __state)
{ |
__instance.fullAutoProjectile = __state.oldProj;
if (__state.tempProj != null)
GameObject.Destroy(__state.tempProj);
}
}
class DruidKnight_FullerBurst
{
public static float offset = 0.5f;
static bool Prefix(Mandalore __instance, int ___shotsLeft)
{
if (___shotsLeft != 40)
return true;
GameObject obj = new GameObject();
obj.transform.position = __instance.transform.position;
AudioSource aud = obj.AddComponent<AudioSource>();
aud.playOnAwake = false;
aud.clip = Plugin.druidKnightFullerAutoAud;
aud.time = offset;
aud.Play();
return true;
}
}
class Drone_Explode
{
static bool Prefix(bool ___exploded, out bool __state)
{
__state = ___exploded;
return true;
}
public static float offset = 0.2f;
static void Postfix(Drone __instance, bool ___exploded, bool __state)
{
if (__state)
return;
if (!___exploded || __instance.gameObject.GetComponent<Mandalore>() == null)
return;
GameObject obj = new GameObject();
obj.transform.position = __instance.transform.position;
AudioSource aud = obj.AddComponent<AudioSource>();
aud.playOnAwake = false;
aud.clip = Plugin.druidKnightDeathAud;
aud.time = offset;
aud.Play();
}
}
}
| Ultrapain/Patches/DruidKnight.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/HideousMass.cs",
"retrieved_chunk": " {\n static void Postfix(Projectile __instance)\n {\n HideousMassProjectile flag = __instance.gameObject.GetComponent<HideousMassProjectile>();\n if (flag == null)\n return;\n GameObject createInsignia(float size, int damage)\n {\n GameObject insignia = GameObject.Instantiate(Plugin.virtueInsignia, __instance.transform.position, Quaternion.identity);\n insignia.transform.localScale = new Vector3(size, 1f, size);",
"score": 0.8267959952354431
},
{
"filename": "Ultrapain/Patches/Panopticon.cs",
"retrieved_chunk": " }\n class Panopticon_SpawnBlackHole\n {\n static void Postfix(FleshPrison __instance, EnemyIdentifier ___eid)\n {\n if (!__instance.altVersion)\n return;\n Vector3 vector = MonoSingleton<PlayerTracker>.Instance.PredictPlayerPosition(0.5f / ___eid.totalSpeedModifier);\n GameObject gameObject = GameObject.Instantiate(Plugin.sisyphusDestroyExplosion, vector, Quaternion.identity);\n GoreZone gz = __instance.GetComponentInParent<GoreZone>();",
"score": 0.8191620111465454
},
{
"filename": "Ultrapain/Patches/SomethingWicked.cs",
"retrieved_chunk": " {\n GameObject goreZone = new GameObject();\n goreZone.AddComponent<GoreZone>();\n Vector3 spawnPos = new Vector3(86.7637f, -39.9667f, 635.7572f);\n if (Physics.Raycast(spawnPos + Vector3.up, Vector3.down, out RaycastHit hit, 100f, new LayerMask() { value = (1 << 8) | (1 << 24) }, QueryTriggerInteraction.Ignore))\n spawnPos = hit.point;\n GameObject wicked = GameObject.Instantiate(Plugin.somethingWicked, spawnPos, Quaternion.identity, goreZone.transform); ;\n wicked.AddComponent<JokeWicked>();\n Wicked comp = wicked.GetComponent<Wicked>();\n comp.patrolPoints = new Transform[] { __instance.transform };",
"score": 0.8164197206497192
},
{
"filename": "Ultrapain/Patches/HideousMass.cs",
"retrieved_chunk": " insignia.transform.Rotate(new Vector3(90f, 0, 0));\n }\n }\n }\n public class HideousMassHoming\n {\n static bool Prefix(Mass __instance, EnemyIdentifier ___eid)\n {\n __instance.explosiveProjectile = GameObject.Instantiate(Plugin.hideousMassProjectile);\n HideousMassProjectile flag = __instance.explosiveProjectile.AddComponent<HideousMassProjectile>();",
"score": 0.814023494720459
},
{
"filename": "Ultrapain/Patches/HideousMass.cs",
"retrieved_chunk": " flag.damageBuf = ___eid.totalDamageModifier;\n flag.speedBuf = ___eid.totalSpeedModifier;\n return true;\n }\n static void Postfix(Mass __instance)\n {\n GameObject.Destroy(__instance.explosiveProjectile);\n __instance.explosiveProjectile = Plugin.hideousMassProjectile;\n }\n }",
"score": 0.8064497113227844
}
] | csharp | Mandalore __instance, StateInfo __state)
{ |
using Serilog;
using Serilog.Core;
using Serilog.Events;
using ShellProgressBar;
using System.ComponentModel;
using System.Diagnostics;
using System.Net;
using System.Reflection;
using DustInTheWind.ConsoleTools.Controls.Menus;
using DustInTheWind.ConsoleTools.Controls.InputControls;
using System;
namespace OGXbdmDumper
{
internal class Program
{
/// <summary>
/// Allows the switching of log event levels without creating a new logger.
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private static readonly LoggingLevelSwitch _levelSwitch = new(LogEventLevel.Information);
/// <summary>
/// The minimum level used to filter message output.
/// </summary>
public static LogEventLevel LogLevel
{
get { return _levelSwitch.MinimumLevel; }
set
{
if (value == _levelSwitch.MinimumLevel) return;
_levelSwitch.MinimumLevel = value;
Log.Information("File logger level changed to {LogEventLevel}", value);
}
}
static void Main(string[] args)
{
try
{
InitializeLogging();
// obtain a connection
using var xbox = GetXboxConnection();
// create dated folder underneath selection to help prevent accidental overwrites
var path = Path.Combine(GetOutputDirectory(), DateTime.Now.ToString("yyyyMMddHHmmss"));
Directory.CreateDirectory(path);
// pause execution to prevent any interference
xbox.Stop();
// dump all the things
DumpXbdmMemory(xbox, Path.Combine(path, "xbdm.dll.memory"));
DumpKernelMemory(xbox, Path.Combine(path, "xboxkrnl.exe.memory"));
DumpBiosImage(xbox, Path.Combine(path, "bios.bin"));
ValidateRpc(xbox);
DumpEeprom(xbox, Path.Combine(path, "eeprom.bin"));
DumpHddImage(xbox, Path.Combine(path, "hdd.img"));
DumpHddFiles(xbox, Path.Combine(path, "hdd"));
// resume execution
xbox.Go();
}
catch (Exception ex)
{
Log.Fatal(ex, "Fatal error encountered!");
}
finally
{
// cleanup
Log.CloseAndFlush();
}
}
public static void InitializeLogging()
{
// initialize logger
Log.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(_levelSwitch)
.WriteTo.Console(restrictedToMinimumLevel: LogEventLevel.Information)
.WriteTo.File("log.txt", buffered: true, flushToDiskInterval: TimeSpan.FromSeconds(1))
.CreateLogger();
// log application information
Log.Information("https://github.com/Ernegien/OGXbdmDumper");
Log.Information("Version {0}", Assembly.GetExecutingAssembly().GetName().Version);
// provide the option for additional log capture
LogLevel = YesNo("Enable verbose file logging?", false) ? LogEventLevel.Verbose : LogEventLevel.Information;
}
public static | Xbox GetXboxConnection()
{ |
var xbox = new Xbox();
// attempt xbox auto-discovery
var xboxen = xbox.Discover();
if (xboxen.Count > 0)
{
var textMenu = new TextMenu
{
TitleText = "The following Xboxes were discovered on the local network:",
QuestionText = "Connect to: "
};
for (int i = 0; i < xboxen.Count; i++)
{
textMenu.AddItem(new TextMenuItem()
{
Id = i.ToString(),
Text = xboxen[i].Endpoint.Address.ToString() +
(string.IsNullOrWhiteSpace(xboxen[i].Name) ? string.Empty : " (" + xboxen[i].Name + ")")
});
}
textMenu.AddItem(new TextMenuItem()
{
Id = xboxen.Count.ToString(),
Text = "Other"
});
textMenu.Display();
if (textMenu.SelectedIndex < xboxen.Count)
{
xbox.Connect(xboxen[textMenu.SelectedIndex.Value].Endpoint);
return xbox;
}
}
else Log.Warning("Auto-discovery failed! Manually enter connection information instead.");
// manual address entry
// TODO: custom parser for ip address
string ip = ValueControl<string>.QuickRead("IP Address:");
var port = new ValueControl<ushort>("Alternate Port [leave blank if no]:")
{
AcceptDefaultValue = true,
DefaultValue = 731
}.Read();
xbox.Connect(new IPEndPoint(IPAddress.Parse(ip), port));
return xbox;
}
public static string GetOutputDirectory()
{
// TODO: custom parser for path validation
var path = ValueControl<string>.QuickRead("Enter output directory path:");
if (!Directory.Exists(path))
throw new DirectoryNotFoundException(path);
Log.Information("Using {0} as the output directory path.", path);
return path;
}
public static void DumpXbdmMemory(Xbox xbox, string path)
{
if (!YesNo("Dump xbdm.dll from memory?"))
return;
Log.Information("Dumping xbdm.dll from memory.");
var xbdm = xbox.Modules.Find(m => m.Name == "xbdm.dll");
if (xbdm != null)
{
File.WriteAllBytes(path, xbox.Memory.ReadBytes(xbdm.BaseAddress, xbdm.Size));
}
}
public static void DumpKernelMemory(Xbox xbox, string path)
{
if (!YesNo("Dump xboxkrnl.exe from memory?"))
return;
Log.Information("Dumping xboxkrnl.exe from memory.");
var kernel = xbox.Modules.Find(m => m.Name == "xboxkrnl.exe");
if (kernel != null)
{
byte[] page = new byte[0x1000];
using var fs = File.Create(path);
using var bw = new BinaryWriter(fs);
// loop through each page in the kernel address range skipping any invalid ones since the init section will be deallocated
for (long position = kernel.BaseAddress; position < kernel.BaseAddress + kernel.Size; position += page.Length)
{
bw.Write(xbox.IsValidAddress(position) ? xbox.Memory.ReadBytes(position, page.Length) : page);
}
}
}
public static void ValidateRpc(Xbox xbox)
{
Log.Information("Validating remote procedure call functionality.");
// mov eax, 0DEADBEEFh
// ret
xbox.WriteMemory(xbox.StaticScratch.Region.Address, new byte[] { 0xB8, 0xEF, 0xBE, 0xAD, 0xDE, 0xC3 });
if (xbox.Call(xbox.StaticScratch.Region.Address) != 0xDEADBEEF)
{
Log.Warning("Remote procedure call failure!");
throw new InvalidDataException();
}
}
public static void DumpEeprom(Xbox xbox, string path)
{
if (!YesNo("Dump EEPROM?"))
return;
Log.Information("Dumping EEPROM.");
// configure progress bar
const int eepromSize = 256;
using var progress = CreatePercentProgressBar();
// read a byte at a time
using var fs = File.Create(path);
using var bw = new BinaryWriter(fs);
for (int i = 0; i < eepromSize; i++)
{
xbox.Kernel.HalReadSMBusValue(0xA8, i, false, xbox.StaticScratch.Region.Address);
bw.Write(xbox.Memory.ReadByte(xbox.StaticScratch.Region.Address));
progress.AsProgress<float>().Report((float)i / eepromSize);
}
progress.AsProgress<float>().Report(1.0f);
}
public static void DumpBiosImage(Xbox xbox, string path)
{
if (!YesNo("Dump BIOS?"))
return;
Log.Information("Dumping BIOS image from flash.");
// take the first 1MB which is enough for all legit development gear
byte[] bios = new byte[1024 * 1024];
// configure progress bar
var chunkSize = 0x1000;
var chunks = bios.Length / chunkSize;
using var progress = CreatePercentProgressBar();
// read 4kb at a time
for (int i = 0; i < chunks; i++)
{
xbox.ReadMemory(0xFF000000 + i * chunkSize, bios, i * chunkSize, chunkSize);
progress.AsProgress<float>().Report((float)i / chunks);
}
progress.AsProgress<float>().Report(1.0f);
// find smallest 256KB-aligned unique chunk since it gets mirrored throughout the upper 16MB range
byte[] testPattern = bios.Take(1024 * 256).ToArray();
int flashSize = bios.IndexOfArray(testPattern, (int)testPattern.Length);
if (flashSize == -1)
flashSize = bios.Length;
File.WriteAllBytes(path, bios.Take(flashSize).ToArray());
}
public static void DumpHddImage(Xbox xbox, string path)
{
if (!YesNo("Dump HDD image?"))
return;
// attempt to allocate a larger scratch buffer and switch to unsafe mode for increased performance
int scratchSize = 1024 * 1024;
uint scratch = (uint)xbox.Kernel.MmAllocateContiguousMemory(scratchSize);
if (scratch == 0)
{
scratch = xbox.StaticScratch.Region.Address;
scratchSize = xbox.StaticScratch.Region.Size;
}
xbox.SafeMode = false;
Log.Information("Dumping HDD image.");
// remote memory map
//FileHandle:
// dd 0
//IoStatusBlock: +4
// dd 0
// dd 0
//ObjectAttributes: +12 ; (OBJECT ATTRIBUTES)
// dd 0 ; HANDLE RootDirectory
// dd ObjectName ; PANSI_STRING ObjectName
// dd 00000040h ; ULONG Attributes = FILE_ATTRIBUTE_DEVICE
//ObjectName: +24 ; (PANSI_STRING)
// dw 26; ; USHORT Length
// dw 26; ; USHORT MaximumLength
// dd FileName ; PCHAR Buffer
// FileName: + 32
// db "\Device\Harddisk0\Partition0", 0
uint fileHandleAddr = scratch;
uint iOStatusBlockAddr = scratch + 4;
uint objectAttributesAddr = scratch + 12;
uint objectNameAddr = scratch + 24;
uint fileNameAddr = scratch + 32;
// initialize remote memory
string name = @"\Device\Harddisk0\Partition0"; // physical disk path
xbox.Memory.Position = scratch;
xbox.Memory.Write((uint)0);
xbox.Memory.Write((uint)0);
xbox.Memory.Write((uint)0);
xbox.Memory.Write((uint)0);
xbox.Memory.Write(objectNameAddr);
xbox.Memory.Write((uint)0x40);
xbox.Memory.Write((ushort)name.Length);
xbox.Memory.Write((ushort)name.Length);
xbox.Memory.Write(fileNameAddr);
xbox.Memory.WriteAscii(name);
xbox.Memory.Write(0);
// obtain a handle to the raw physical hdd device
var status = xbox.Call(xbox.Kernel.Exports.NtOpenFile,
fileHandleAddr, // PHANDLE FileHandle
0xC0000000, // ACCESS_MASK DesiredAccess = GENERIC_WRITE | GENERIC_READ
objectAttributesAddr, // POBJECT_ATTRIBUTES ObjectAttributes
iOStatusBlockAddr, // PIO_STATUS_BLOCK IoStatusBlock
(uint)3, // ULONG ShareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE
(uint)0x60 // ULONG OpenOptions = FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
);
if (status != 0)
throw new Win32Exception((int)status);
uint handle = xbox.Memory.ReadUInt32(fileHandleAddr);
// memory map
var geometryInfoAddr = scratch + 100;
var geometryInfoSize = 24;
// get the disk geometry information
status = xbox.Call(xbox.Kernel.Exports.NtDeviceIoControlFile,
handle, // HANDLE FileHandle
0, // HANDLE Event
0, // PIO_APC_ROUTINE ApcRoutine
0, // PVOID ApcContext
iOStatusBlockAddr, // PIO_STATUS_BLOCK IoStatusBlock
(7 << 16) | (0 << 14) | (0 << 2) | 0, // ULONG IoControlCode = IOCTL_DISK_BASE << 16 | FILE_ANY_ACCESS << 14 | Function << 2 | METHOD_BUFFERED
0, // PVOID InputBuffer
0, // ULONG InputBufferLength
geometryInfoAddr, // PVOID OutputBuffer
geometryInfoSize // ULONG OutputBufferLength
);
if (status != 0)
throw new Win32Exception((int)status);
// calculate the total raw disk size
long cylinders = xbox.Memory.ReadInt64(geometryInfoAddr);
int tracksPerCylinder = xbox.Memory.ReadInt32(geometryInfoAddr + 12);
int sectorsPerTrack = xbox.Memory.ReadInt32(geometryInfoAddr + 16);
long bytesPerSector = xbox.Memory.ReadInt32(geometryInfoAddr + 20);
long size = cylinders * tracksPerCylinder * sectorsPerTrack * bytesPerSector;
Log.Information("Detected {0} GB HDD ({1} bytes).", (int)((float)size / (1024 * 1024 * 1024)), size.ToHexString());
// get the required 4KB-aligned/sized buffer within scratch space
uint bufferAddress = scratch + 16; // first 16 bytes of scratch is reserved for NtReadFile args
bufferAddress = (bufferAddress + 0xFFF) & 0xFFFFF000; // align up to the next 4KB
uint bufferSize = (uint)(scratch + scratchSize - bufferAddress);
bufferSize &= 0xFFFFF000; // align down to the next 4KB
byte[] buffer = new byte[bufferSize];
// make sure we haven't gone too far
if (bufferSize == 0)
throw new OutOfMemoryException("Not enough aligned scratch space!");
using var progress = CreatePercentProgressBar();
using var fs = File.Create(path);
using var bw = new BinaryWriter(fs);
long diskOffset = 0;
while (diskOffset < size)
{
uint bytesToRead = (uint)Math.Min((ulong)bufferSize, (ulong)(size - diskOffset));
Log.Verbose("Reading {0} bytes from disk offset {1}", bytesToRead, diskOffset);
try
{
xbox.Memory.Write(scratch, diskOffset);
xbox.Kernel.NtReadFile(
handle, // HANDLE FileHandle
0, // HANDLE Event
0, // PIO_APC_ROUTINE ApcRoutine
0, // PVOID ApcContext
scratch + 8, // PIO_STATUS_BLOCK IoStatusBlock
bufferAddress, // PVOID Buffer
bytesToRead, // ULONG Length
scratch // PLARGE_INTEGER ByteOffset
);
xbox.ReadMemory(bufferAddress, buffer, 0, (int)bytesToRead);
}
catch (Exception ex)
{
Log.Warning(ex, "Read failure at {0}", diskOffset.ToHexString());
buffer = new byte[bytesToRead];
}
finally
{
bw.Write(buffer);
fs.Flush();
diskOffset += bytesToRead;
}
progress.AsProgress<float>().Report((float)diskOffset / size);
}
progress.AsProgress<float>().Report(1.0f);
// cleanup
xbox.Kernel.NtClose(handle);
xbox.Kernel.MmFreeContiguousMemory(scratch);
}
private static void DumpDirectory(Xbox xbox, string remotePath, string localPath)
{
Log.Information("Downloading {0}", remotePath);
Directory.CreateDirectory(localPath);
try
{
var list = xbox.GetDirectoryList(remotePath);
foreach (var item in list)
{
if (item.Attributes.HasFlag(FileAttributes.Directory))
{
DumpDirectory(xbox, item.FullName, Path.Combine(localPath, item.Name));
}
else
{
try
{
Log.Information("Downloading file {0}", item.Name);
xbox.GetFile(Path.Combine(localPath, item.Name), item.FullName);
}
catch (Exception ex)
{
Log.Warning(ex, item.Name);
}
}
}
}
catch (Exception ex)
{
Log.Warning(ex, remotePath);
}
}
public static void DumpHddFiles(Xbox xbox, string path)
{
if (!YesNo("Dump files from HDD?"))
return;
Log.Information("Dumping files from hdd.");
foreach (var drive in xbox.GetDrives())
{
DumpDirectory(xbox, drive.ToString() + ":\\", Path.Combine(path, drive.ToString()));
}
}
private static ProgressBar CreatePercentProgressBar()
{
return new ProgressBar(10000, "Completed",
new ProgressBarOptions
{
ForegroundColor = ConsoleColor.Yellow,
ForegroundColorDone = ConsoleColor.DarkGreen,
BackgroundColor = ConsoleColor.DarkGray,
BackgroundCharacter = '\u2593'
});
}
private static bool YesNo(string question, bool defaultYes = true)
{
var yesNoQuestion = new YesNoQuestion(question)
{
DefaultAnswer = defaultYes ? YesNoAnswer.Yes : YesNoAnswer.No
};
return yesNoQuestion.ReadAnswer() == YesNoAnswer.Yes;
}
}
} | src/OGXbdmDumper/Program.cs | Ernegien-OGXbdmDumper-07a1e82 | [
{
"filename": "src/OGXbdmDumper/Kernel.cs",
"retrieved_chunk": " // get the version\n Version = xbox.Memory.ReadInt32(Exports.XboxKrnlVersion).ToVersion();\n // log export disassembly for debugging purposes when verbose is enabled\n if (Log.Logger.IsEnabled(LogEventLevel.Verbose))\n {\n foreach (PropertyInfo prop in Exports.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))\n {\n if (prop.Name.Equals(\"XboxKrnlVersion\"))\n continue;\n Log.Verbose(\"{0} disassembly snippet.\" + Environment.NewLine + ",
"score": 0.8371754288673401
},
{
"filename": "src/OGXbdmDumper/Xbox.cs",
"retrieved_chunk": " Log.Information(\"Loaded Modules:\");\n foreach (var module in Modules)\n {\n Log.Information(\"\\t{0} ({1})\", module.Name, module.TimeStamp);\n }\n Log.Information(\"Xbdm Version {0}\", Version);\n Log.Information(\"Kernel Version {0}\", Kernel.Version);\n // enable remote code execution and use the remainder reloc section as scratch\n PatchXbdm(this);\n }",
"score": 0.8272264003753662
},
{
"filename": "src/OGXbdmDumper/Xbox.cs",
"retrieved_chunk": " catch\n {\n version = new Version(\"0.0.0.0\");\n }\n }\n return version;\n }\n public void Stop()\n {\n Log.Information(\"Suspending xbox execution.\");",
"score": 0.7866849303245544
},
{
"filename": "src/OGXbdmDumper/Xbox.cs",
"retrieved_chunk": " Log.Verbose(buffer.ToHexString());\n }\n }\n else if (!SafeMode)\n {\n // custom getmem2\n Session.SendCommandStrict(\"funccall type=1 addr={0} length={1}\", address, buffer.Length);\n Session.ReadExactly(buffer);\n if (Log.IsEnabled(LogEventLevel.Verbose))\n {",
"score": 0.7809540033340454
},
{
"filename": "src/OGXbdmDumper/Xbox.cs",
"retrieved_chunk": " Session.SendCommand(\"stop\");\n }\n public void Go()\n {\n Log.Information(\"Resuming xbox execution.\");\n Session.SendCommand(\"go\");\n }\n /// <summary>\n /// Calls an Xbox function.\n /// </summary>",
"score": 0.7745484113693237
}
] | csharp | Xbox GetXboxConnection()
{ |
using Ryan.EntityFrameworkCore.Builder;
using Ryan.EntityFrameworkCore.Dynamic;
using Ryan.EntityFrameworkCore.Expressions;
using Ryan.EntityFrameworkCore.Proxy;
using Ryan.EntityFrameworkCore.Query;
namespace Ryan.DependencyInjection
{
/// <inheritdoc cref="IShardDependency"/>
public class ShardDependency : IShardDependency
{
public ShardDependency(
IDynamicSourceCodeGenerator dynamicSourceCodeGenerator
, IDynamicTypeGenerator dynamicTypeGenerator
, IEntityModelBuilderGenerator entityModelBuilderGenerator
, IEntityImplementationDictionaryGenerator entityImplementationDictionaryGenerator
, IEntityModelBuilderAccessorGenerator entityModelBuilderAccessorGenerator
, IEntityShardConfiguration entityShardConfiguration
, IEntityProxyGenerator entityProxyGenerator
, IDbContextEntityProxyLookupGenerator dbContextEntityProxyLookupGenerator
, IDbContextEntityProxyGenerator dbContextEntityProxyGenerator
, IQueryableFinder queryableFinder
, | IExpressionImplementationFinder expressionImplementationFinder)
{ |
DynamicSourceCodeGenerator = dynamicSourceCodeGenerator;
DynamicTypeGenerator = dynamicTypeGenerator;
EntityModelBuilderGenerator = entityModelBuilderGenerator;
EntityImplementationDictionaryGenerator = entityImplementationDictionaryGenerator;
EntityModelBuilderAccessorGenerator = entityModelBuilderAccessorGenerator;
EntityShardConfiguration = entityShardConfiguration;
EntityProxyGenerator = entityProxyGenerator;
DbContextEntityProxyLookupGenerator = dbContextEntityProxyLookupGenerator;
DbContextEntityProxyGenerator = dbContextEntityProxyGenerator;
QueryableFinder = queryableFinder;
ExpressionImplementationFinder = expressionImplementationFinder;
}
public IDynamicSourceCodeGenerator DynamicSourceCodeGenerator { get; }
public IDynamicTypeGenerator DynamicTypeGenerator { get; }
public IEntityModelBuilderGenerator EntityModelBuilderGenerator { get; }
public IEntityImplementationDictionaryGenerator EntityImplementationDictionaryGenerator { get; }
public IEntityModelBuilderAccessorGenerator EntityModelBuilderAccessorGenerator { get; }
public IEntityShardConfiguration EntityShardConfiguration { get; }
public IEntityProxyGenerator EntityProxyGenerator { get; }
public IDbContextEntityProxyLookupGenerator DbContextEntityProxyLookupGenerator { get; }
public IDbContextEntityProxyGenerator DbContextEntityProxyGenerator { get; }
public IQueryableFinder QueryableFinder { get; }
public IExpressionImplementationFinder ExpressionImplementationFinder { get; }
}
}
| src/Ryan.EntityFrameworkCore.Shard/DependencyInjection/ShardDependency.cs | c-y-r-Ryan.EntityFrameworkCore.Shard-f15124c | [
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/DependencyInjection/IShardDependency.cs",
"retrieved_chunk": " public interface IShardDependency\n {\n IDynamicSourceCodeGenerator DynamicSourceCodeGenerator { get; }\n IDynamicTypeGenerator DynamicTypeGenerator { get; }\n IEntityModelBuilderGenerator EntityModelBuilderGenerator { get; }\n IEntityImplementationDictionaryGenerator EntityImplementationDictionaryGenerator { get; }\n IEntityModelBuilderAccessorGenerator EntityModelBuilderAccessorGenerator { get; }\n IEntityShardConfiguration EntityShardConfiguration { get; }\n IEntityProxyGenerator EntityProxyGenerator { get; }\n IDbContextEntityProxyLookupGenerator DbContextEntityProxyLookupGenerator { get; }",
"score": 0.87688148021698
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/EntityProxyGenerator.cs",
"retrieved_chunk": " {\n EntityModelBuilderGenerator = entityModelBuilderGenerator;\n EntityImplementationDictionaryGenerator = entityImplementationDictionaryGenerator;\n }\n /// <inheritdoc/>\n public EntityProxy Create(object entity, EntityProxyType type, DbContext dbContext)\n {\n if (type == EntityProxyType.NonQuery)\n {\n var builder = (EntityModelBuilderGenerator.Create(entity.GetType()) as IEntityModelBuilder)!;",
"score": 0.8459989428520203
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Builder/EntityModelBuilderAccessorGenerator.cs",
"retrieved_chunk": " /// <summary>\n /// 创建实体模型构建访问器\n /// </summary>\n public EntityModelBuilderAccessorGenerator(\n IEntityModelBuilderGenerator entityModelBuilderGenerator\n , IEntityImplementationDictionaryGenerator implementationDictionaryGenerator)\n {\n EntityModelBuilderGenerator = entityModelBuilderGenerator;\n ImplementationDictionaryGenerator = implementationDictionaryGenerator;\n MemoryCache = new InternalMemoryCache();",
"score": 0.8441125154495239
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/EntityProxyGenerator.cs",
"retrieved_chunk": " /// <inheritdoc cref=\"IEntityModelBuilderGenerator\"/>\n public IEntityModelBuilderGenerator EntityModelBuilderGenerator { get; }\n /// <inheritdoc cref=\"IEntityImplementationDictionaryGenerator\"/>\n public IEntityImplementationDictionaryGenerator EntityImplementationDictionaryGenerator { get; }\n /// <summary>\n /// 创建实体代理\n /// </summary>\n public EntityProxyGenerator(\n IEntityModelBuilderGenerator entityModelBuilderGenerator\n , IEntityImplementationDictionaryGenerator entityImplementationDictionaryGenerator)",
"score": 0.8360549211502075
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/DbContextEntityProxyLookup.cs",
"retrieved_chunk": " private readonly IDbContextEntityProxyGenerator _dbContextEntityProxyGenerator;\n public DbContextEntityProxyLookup(IDbContextEntityProxyGenerator dbContextEntityProxyGenerator)\n {\n _dbContextEntityProxyGenerator = dbContextEntityProxyGenerator;\n }\n public DbContextEntityProxy GetOrDefault(Type entityType, DbContext context)\n {\n return GetOrAdd(entityType, _dbContextEntityProxyGenerator.Create(context));\n }\n public void Changes()",
"score": 0.8243194222450256
}
] | csharp | IExpressionImplementationFinder expressionImplementationFinder)
{ |
using Microsoft.AspNetCore.Mvc;
using RedisCache;
namespace RedisCacheDemo.Controllers
{
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
private static readonly string[] Summaries = new[]
{
"Freezing", "Bracing", "Chilly", "Cool",
"Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};
private readonly ILogger<WeatherForecastController> _logger;
private readonly ICacheService _cacheService;
public WeatherForecastController(ILogger<WeatherForecastController> logger, ICacheService cacheService)
{
_logger = logger;
_cacheService = cacheService;
}
[HttpGet(Name = "GetWeatherForecast")]
public async Task<IEnumerable<WeatherForecast>> Get()
{
var cacheData = GetKeyValues();
if (cacheData.Any())
{
return cacheData.Values;
}
var newData = Enumerable.Range(1, 10).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
}).ToArray();
await Save(newData, 50).ConfigureAwait(false);
return newData;
}
[HttpGet(nameof(WeatherForecast))]
public WeatherForecast Get(int id)
{
var cacheData = GetKeyValues();
cacheData.TryGetValue(id, out var filteredData);
return filteredData;
}
[HttpPost("addWeatherForecasts/{durationMinutes}")]
public async Task<WeatherForecast[]> PostList( | WeatherForecast[] values, int durationMinutes)
{ |
var cacheData = GetKeyValues();
foreach (var value in values)
{
cacheData[value.Id] = value;
}
await Save(cacheData.Values, durationMinutes).ConfigureAwait(false);
return values;
}
[HttpPost("addWeatherForecast")]
public async Task<WeatherForecast> Post(WeatherForecast value)
{
var cacheData = GetKeyValues();
cacheData[value.Id] = value;
await Save(cacheData.Values).ConfigureAwait(false);
return value;
}
[HttpPut("updateWeatherForecast")]
public async void Put(WeatherForecast WeatherForecast)
{
var cacheData = GetKeyValues();
cacheData[WeatherForecast.Id] = WeatherForecast;
await Save(cacheData.Values).ConfigureAwait(false);
}
[HttpDelete("deleteWeatherForecast")]
public async Task Delete(int id)
{
var cacheData = GetKeyValues();
cacheData.Remove(id);
await Save(cacheData.Values).ConfigureAwait(false);
}
[HttpDelete("ClearAll")]
public async Task Delete()
{
await _cacheService.ClearAsync();
}
private Task<bool> Save(IEnumerable<WeatherForecast> weatherForecasts, double expireAfterMinutes = 50)
{
var expirationTime = DateTimeOffset.Now.AddMinutes(expireAfterMinutes);
return _cacheService.AddOrUpdateAsync(nameof(WeatherForecast), weatherForecasts, expirationTime);
}
private Dictionary<int, WeatherForecast> GetKeyValues()
{
var data = _cacheService.Get<IEnumerable<WeatherForecast>>(nameof(WeatherForecast));
return data?.ToDictionary(key => key.Id, val => val) ?? new Dictionary<int, WeatherForecast>();
}
}
} | src/RedisCache.Demo/Controllers/WeatherForecastController.cs | bezzad-RedisCache.NetDemo-655b311 | [
{
"filename": "src/RedisCache.Benchmark/BenchmarkManager.cs",
"retrieved_chunk": " _memCache.Set(ReadKeyPrefix, _singleModel.Value, DateTimeOffset.Now.AddSeconds(ExpireDurationSecond));\n // read cache\n for (var i = 0; i < RepeatCount; i++)\n if (_memCache.TryGetValue(ReadKeyPrefix, out string value))\n ThrowIfIsNotMatch(JsonSerializer.Deserialize<SampleModel>(value), _singleModel.Value);\n }\n [Benchmark]\n public async Task Get_InMemory_Async()\n {\n // write single cache",
"score": 0.7472250461578369
},
{
"filename": "src/RedisCache.Benchmark/BenchmarkManager.cs",
"retrieved_chunk": " if (value == null)\n throw new ArgumentNullException(nameof(value));\n }\n }\n [Benchmark]\n public async Task Get_HybridRedisCache_Async()\n {\n // write single cache\n await _hybridCache.SetAsync(ReadKeyPrefix, _singleModel.Value, TimeSpan.FromSeconds(ExpireDurationSecond), fireAndForget: true);\n // read cache",
"score": 0.7417806386947632
},
{
"filename": "src/RedisCache.Benchmark/BenchmarkManager.cs",
"retrieved_chunk": " public async Task Add_HybridRedisCache_Async()\n {\n // write cache\n for (var i = 0; i < RepeatCount; i++)\n await _hybridCache.SetAsync(KeyPrefix + i, _data[i], TimeSpan.FromSeconds(ExpireDurationSecond), fireAndForget: true);\n }\n [Benchmark]\n public void Get_InMemory()\n {\n // write single cache",
"score": 0.7284973859786987
},
{
"filename": "src/RedisCache.Benchmark/BenchmarkManager.cs",
"retrieved_chunk": " for (var i = 0; i < RepeatCount; i++)\n _memCache.Set(KeyPrefix + i, JsonSerializer.Serialize(_data[i]), DateTimeOffset.Now.AddSeconds(ExpireDurationSecond));\n }\n [Benchmark]\n public async Task Add_InMemory_Async()\n {\n // write cache\n for (var i = 0; i < RepeatCount; i++)\n await _memCache.GetOrCreateAsync(KeyPrefix + i, _ => Task.FromResult(JsonSerializer.Serialize(_data[i])));\n }",
"score": 0.7273387908935547
},
{
"filename": "src/RedisCache.Benchmark/BenchmarkManager.cs",
"retrieved_chunk": " [Benchmark]\n public void Add_Redis()\n {\n // write cache\n for (var i = 0; i < RepeatCount; i++)\n _redisCache.AddOrUpdate(KeyPrefix + i, _data[i], DateTimeOffset.Now.AddSeconds(ExpireDurationSecond));\n }\n [Benchmark]\n public async Task Add_Redis_Async()\n {",
"score": 0.7255468368530273
}
] | csharp | WeatherForecast[] values, int durationMinutes)
{ |
using HarmonyLib;
using System.Security.Cryptography;
using UnityEngine;
namespace Ultrapain.Patches
{
class SwordsMachineFlag : MonoBehaviour
{
public SwordsMachine sm;
public Animator anim;
public EnemyIdentifier eid;
public bool speedingUp = false;
private void ResetAnimSpeed()
{
if(anim.GetCurrentAnimatorStateInfo(0).IsName("Knockdown"))
{
Invoke("ResetAnimSpeed", 0.01f);
return;
}
Debug.Log("Resetting speed");
speedingUp = false;
sm.SendMessage("SetSpeed");
}
private void Awake()
{
anim = GetComponent<Animator>();
eid = GetComponent<EnemyIdentifier>();
}
public float speed = 1f;
private void Update()
{
if (speedingUp)
{
if (anim == null)
{
anim = sm.GetComponent<Animator>();
if (anim == null)
{
Destroy(this);
return;
}
}
anim.speed = speed;
}
}
}
class SwordsMachine_Start
{
static void Postfix(SwordsMachine __instance)
{
SwordsMachineFlag flag = __instance.gameObject.AddComponent<SwordsMachineFlag>();
flag.sm = __instance;
}
}
class SwordsMachine_Knockdown_Patch
{
static bool Prefix(SwordsMachine __instance, bool __0)
{
__instance.Enrage();
if (!__0)
__instance.SwordCatch();
return false;
}
}
class SwordsMachine_Down_Patch
{
static bool Prefix(SwordsMachine __instance)
{
if (ConfigManager.swordsMachineSecondPhaseMode.value == ConfigManager.SwordsMachineSecondPhase.Skip && __instance.secondPhasePosTarget == null)
return false;
return true;
}
static void Postfix( | SwordsMachine __instance, Animator ___anim, EnemyIdentifier ___eid)
{ |
if (ConfigManager.swordsMachineSecondPhaseMode.value != ConfigManager.SwordsMachineSecondPhase.SpeedUp || __instance.secondPhasePosTarget != null)
return;
SwordsMachineFlag flag = __instance.GetComponent<SwordsMachineFlag>();
if (flag == null)
{
flag = __instance.gameObject.AddComponent<SwordsMachineFlag>();
flag.sm = __instance;
}
flag.speedingUp = true;
flag.speed = (1f * ___eid.totalSpeedModifier) * ConfigManager.swordsMachineSecondPhaseSpeed.value;
___anim.speed = flag.speed;
AnimatorClipInfo clipInfo = ___anim.GetCurrentAnimatorClipInfo(0)[0];
flag.Invoke("ResetAnimSpeed", clipInfo.clip.length / flag.speed);
}
}
class SwordsMachine_EndFirstPhase_Patch
{
static bool Prefix(SwordsMachine __instance)
{
if (ConfigManager.swordsMachineSecondPhaseMode.value == ConfigManager.SwordsMachineSecondPhase.Skip && __instance.secondPhasePosTarget == null)
return false;
return true;
}
static void Postfix(SwordsMachine __instance, Animator ___anim, EnemyIdentifier ___eid)
{
if (ConfigManager.swordsMachineSecondPhaseMode.value != ConfigManager.SwordsMachineSecondPhase.SpeedUp || __instance.secondPhasePosTarget != null)
return;
SwordsMachineFlag flag = __instance.GetComponent<SwordsMachineFlag>();
if (flag == null)
{
flag = __instance.gameObject.AddComponent<SwordsMachineFlag>();
flag.sm = __instance;
}
flag.speedingUp = true;
flag.speed = (1f * ___eid.totalSpeedModifier) * ConfigManager.swordsMachineSecondPhaseSpeed.value;
___anim.speed = flag.speed;
AnimatorClipInfo clipInfo = ___anim.GetCurrentAnimatorClipInfo(0)[0];
flag.Invoke("ResetAnimSpeed", clipInfo.clip.length / flag.speed);
}
}
/*class SwordsMachine_SetSpeed_Patch
{
static bool Prefix(SwordsMachine __instance, ref Animator ___anim)
{
if (___anim == null)
___anim = __instance.GetComponent<Animator>();
SwordsMachineFlag flag = __instance.GetComponent<SwordsMachineFlag>();
if (flag == null || !flag.speedingUp)
return true;
return false;
}
}*/
/*[HarmonyPatch(typeof(SwordsMachine))]
[HarmonyPatch("Down")]
class SwordsMachine_Down_Patch
{
static void Postfix(SwordsMachine __instance, ref Animator ___anim, ref Machine ___mach)
{
___anim.Play("Knockdown", 0, Plugin.SwordsMachineKnockdownTimeNormalized);
__instance.CancelInvoke("CheckLoop");
___mach.health = ___mach.symbiote.health;
__instance.downed = false;
}
}
[HarmonyPatch(typeof(SwordsMachine))]
[HarmonyPatch("CheckLoop")]
class SwordsMachine_CheckLoop_Patch
{
static bool Prefix(SwordsMachine __instance)
{
return false;
}
}*/
/*[HarmonyPatch(typeof(SwordsMachine))]
[HarmonyPatch("ShootGun")]
class SwordsMachine_ShootGun_Patch
{
static bool Prefix(SwordsMachine __instance)
{
if(UnityEngine.Random.RandomRangeInt(0, 2) == 1)
{
GameObject grn = GameObject.Instantiate(Plugin.shotgunGrenade.gameObject, __instance.transform.position, __instance.transform.rotation);
grn.transform.position += grn.transform.forward * 0.5f + grn.transform.up * 0.5f;
Grenade grnComp = grn.GetComponent<Grenade>();
grnComp.enemy = true;
grnComp.CanCollideWithPlayer(true);
Vector3 playerPosition = MonoSingleton<PlayerTracker>.Instance.gameObject.transform.position;
float distanceFromPlayer = Vector3.Distance(playerPosition, grn.transform.position);
Vector3 predictedPosition = MonoSingleton<PlayerTracker>.Instance.PredictPlayerPosition(distanceFromPlayer / 40);
grn.transform.LookAt(predictedPosition);
grn.GetComponent<Rigidbody>().maxAngularVelocity = 40;
grn.GetComponent<Rigidbody>().velocity = grn.transform.forward * 40;
return false;
}
return true;
}
}*/
class ThrownSword_Start_Patch
{
static void Postfix(ThrownSword __instance)
{
__instance.gameObject.AddComponent<ThrownSwordCollisionDetector>();
}
}
class ThrownSword_OnTriggerEnter_Patch
{
static void Postfix(ThrownSword __instance, Collider __0)
{
if (__0.gameObject.tag == "Player")
{
GameObject explosionObj = GameObject.Instantiate(Plugin.shotgunGrenade.gameObject.GetComponent<Grenade>().explosion, __0.gameObject.transform.position, __0.gameObject.transform.rotation);
foreach (Explosion explosion in explosionObj.GetComponentsInChildren<Explosion>())
{
explosion.enemy = true;
}
}
}
}
class ThrownSwordCollisionDetector : MonoBehaviour
{
public bool exploded = false;
public void OnCollisionEnter(Collision other)
{
if (exploded)
return;
if (other.gameObject.layer != 24)
{
Debug.Log($"Hit layer {other.gameObject.layer}");
return;
}
exploded = true;
GameObject explosionObj = GameObject.Instantiate(Plugin.shotgunGrenade.gameObject.GetComponent<Grenade>().explosion, transform.position, transform.rotation);
foreach (Explosion explosion in explosionObj.GetComponentsInChildren<Explosion>())
{
explosion.enemy = true;
explosion.damage = ConfigManager.swordsMachineExplosiveSwordDamage.value;
explosion.maxSize *= ConfigManager.swordsMachineExplosiveSwordSize.value;
explosion.speed *= ConfigManager.swordsMachineExplosiveSwordSize.value;
}
gameObject.GetComponent<ThrownSword>().Invoke("Return", 0.1f);
}
}
}
| Ultrapain/Patches/SwordsMachine.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/MinosPrime.cs",
"retrieved_chunk": " public bool explosionAttack = false;\n }\n class MinosPrime_Start\n {\n static void Postfix(MinosPrime __instance, Animator ___anim, ref bool ___enraged)\n {\n if (ConfigManager.minosPrimeEarlyPhaseToggle.value)\n ___enraged = true;\n __instance.gameObject.AddComponent<MinosPrimeFlag>();\n if (ConfigManager.minosPrimeComboExplosionToggle.value)",
"score": 0.8048933744430542
},
{
"filename": "Ultrapain/Patches/Cerberus.cs",
"retrieved_chunk": " if (flag == null)\n return;\n if (___anim.GetCurrentAnimatorClipInfo(0)[0].clip.name != \"Tackle\")\n return;\n flag.MakeParryable();\n }\n }\n class StatueBoss_Stomp_Patch\n {\n static void Postfix(StatueBoss __instance)",
"score": 0.7963266372680664
},
{
"filename": "Ultrapain/Patches/MinosPrime.cs",
"retrieved_chunk": " }\n }\n // aka JUDGEMENT\n class MinosPrime_Dropkick\n {\n static bool Prefix(MinosPrime __instance, EnemyIdentifier ___eid, ref bool ___inAction, Animator ___anim)\n {\n MinosPrimeFlag flag = __instance.GetComponent<MinosPrimeFlag>();\n if (flag == null)\n return true;",
"score": 0.7869158983230591
},
{
"filename": "Ultrapain/Patches/StreetCleaner.cs",
"retrieved_chunk": " return true;\n }\n static void Postfix(Streetcleaner __instance, ref EnemyIdentifier ___eid)\n {\n if(__instance.IsInvoking(\"StartFire\") && cancelStartFireInvoke)\n {\n __instance.CancelInvoke(\"StartFire\");\n __instance.Invoke(\"StartFire\", 0.1f);\n }\n }",
"score": 0.7774994969367981
},
{
"filename": "Ultrapain/Patches/FleshPrison.cs",
"retrieved_chunk": " {\n if (__instance.altVersion)\n return true;\n if (__instance.eid == null)\n __instance.eid = __instance.GetComponent<EnemyIdentifier>();\n __instance.eid.overrideFullName = ConfigManager.fleshObamiumName.value;\n return true;\n }\n static void Postfix(FleshPrison __instance)\n {",
"score": 0.7753524780273438
}
] | csharp | SwordsMachine __instance, Animator ___anim, EnemyIdentifier ___eid)
{ |
using Moadian.Dto;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace Moadian.Services
{
public class HttpClientService
{
private readonly HttpClient client;
private readonly SignatureService signatureService;
private readonly EncryptionService encryptionService;
public HttpClientService( | SignatureService signatureService, EncryptionService encryptionService, string baseUri = "https://tp.tax.gov.ir")
{ |
client = new HttpClient
{
BaseAddress = new Uri(baseUri)
};
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
this.signatureService = signatureService;
this.encryptionService = encryptionService;
}
public async Task<object?> SendPacket(string path, Packet packet, Dictionary<string, string> headers)
{
var cloneHeader = new Dictionary<string, string>(headers);
if (cloneHeader.ContainsKey("Authorization"))
{
cloneHeader["Authorization"] = cloneHeader["Authorization"].Replace("Bearer ", "");
}
var pack = packet.ToArray();
foreach (var item in cloneHeader)
{
pack.Add(item.Key, item.Value);
}
var normalizedData = Normalizer.NormalizeArray(pack);
var signature = signatureService.Sign(normalizedData);
var content = new Dictionary<string, object>
{
{ "packet", packet.ToArray() },
{ "signature", signature }
};
string contentJson = JsonConvert.SerializeObject(content);
var response = await Post(path, contentJson, headers);
var stringData = await response.Content.ReadAsStringAsync();
return JsonConvert.DeserializeObject(stringData);
}
public async Task<object> SendPackets(string path, List<Packet> packets, Dictionary<string, string> headers, bool encrypt = false, bool sign = false)
{
headers = FillEssentialHeaders(headers);
if (sign)
{
foreach (var packet in packets)
{
SignPacket(packet);
}
}
if (encrypt)
{
packets = EncryptPackets(packets);
}
var cloneHeader = new Dictionary<string, string>(headers);
cloneHeader["Authorization"] = cloneHeader["Authorization"].Replace("Bearer ", "");
var pack = packets[0].ToArray();
foreach (var item in cloneHeader)
{
pack.Add(item.Key, item.Value);
}
var normalized = Normalizer.NormalizeArray(pack);
var signature = signatureService.Sign(normalized);
var content = new Dictionary<string, object>
{
{ "packets", packets.ConvertAll(p => p.ToArray()) },
{ "signature", signature },
{ "signatureKeyId", null }
};
return await Post(path, JsonConvert.SerializeObject(content), headers);
}
private void SignPacket(Packet packet)
{
var normalized = Normalizer.NormalizeArray(packet.data is string ? null : ((PacketDataInterface)packet.data)?.ToArray());
var signature = signatureService.Sign(normalized);
packet.dataSignature = signature;
// TODO: Not sure?
// packet.SetSignatureKeyId(signatureService.GetKeyId());
}
private List<Packet> EncryptPackets(List<Packet> packets)
{
var aesHex = BitConverter.ToString(RandomNumberGenerator.GetBytes(32)).Replace("-", "");
var iv = BitConverter.ToString(RandomNumberGenerator.GetBytes(16)).Replace("-", "");
var encryptedAesKey = encryptionService.EncryptAesKey(aesHex);
foreach (var packet in packets)
{
packet.iv = iv;
packet.symmetricKey = encryptedAesKey;
packet.encryptionKeyId = encryptionService.GetEncryptionKeyId();
packet.data = (Encoding.UTF8.GetBytes(encryptionService.Encrypt(JsonConvert.SerializeObject(packet.data is string ? packet.data : ((PacketDataInterface)packet.data)?.ToArray()), hex2bin(aesHex), hex2bin(iv))));
}
return packets;
}
private async Task<HttpResponseMessage> Post(string path, string content, Dictionary<string, string> headers = null)
{
var request = new HttpRequestMessage(HttpMethod.Post, path);
request.Content = new StringContent(content, Encoding.UTF8, "application/json");
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
return await client.SendAsync(request);
}
/**
* @param Dictionary<string, string> headers
* @return Dictionary<string, string>
*/
private Dictionary<string, string> FillEssentialHeaders(Dictionary<string, string> headers)
{
if (!headers.ContainsKey(Constants.TransferConstants.TIMESTAMP_HEADER))
{
headers.Add(Constants.TransferConstants.TIMESTAMP_HEADER, "1678654079000");
}
if (!headers.ContainsKey(Constants.TransferConstants.REQUEST_TRACE_ID_HEADER))
{
headers.Add(Constants.TransferConstants.REQUEST_TRACE_ID_HEADER, "AAA");
}
return headers;
}
private byte[] hex2bin(string hexdata)
{
if (hexdata == null)
throw new ArgumentNullException("hexdata");
if (hexdata.Length % 2 != 0)
throw new ArgumentException("hexdata should have even length");
byte[] bytes = new byte[hexdata.Length / 2];
for (int i = 0; i < hexdata.Length; i += 2)
bytes[i / 2] = (byte)(HexValue(hexdata[i]) * 0x10
+ HexValue(hexdata[i + 1]));
return bytes;
}
private int HexValue(char c)
{
int ch = (int)c;
if (ch >= (int)'0' && ch <= (int)'9')
return ch - (int)'0';
if (ch >= (int)'a' && ch <= (int)'f')
return ch - (int)'a' + 10;
if (ch >= (int)'A' && ch <= (int)'F')
return ch - (int)'A' + 10;
throw new ArgumentException("Not a hexadecimal digit.");
}
}
}
| Services/HttpClientService.cs | Torabi-srh-Moadian-482c806 | [
{
"filename": "API/API.cs",
"retrieved_chunk": "{\n public class Api\n {\n private TokenModel? token = null;\n private readonly string username;\n private readonly HttpClientService httpClient;\n public Api(string username, HttpClientService httpClient)\n {\n this.username = username;\n this.httpClient = httpClient;",
"score": 0.8980278968811035
},
{
"filename": "Moadian.cs",
"retrieved_chunk": " this.Username = username;\n this.BaseURL = baseURL;\n var signatureService = new SignatureService(PrivateKey);\n var encryptionService = new EncryptionService(publicKey, orgKeyId);\n this.httpClient = new HttpClientService(signatureService, encryptionService, baseURL);\n }\n public string PublicKey { get; }\n public string PrivateKey { get; }\n public string OrgKeyId { get; }\n public string Username { get; }",
"score": 0.8448818922042847
},
{
"filename": "Moadian.cs",
"retrieved_chunk": " protected readonly string privateKey;\n protected readonly string orgKeyId;\n protected readonly string username;\n protected readonly string baseURL;\n protected readonly HttpClientService httpClient;\n public Moadian(string publicKey, string privateKey, string orgKeyId, string username, string baseURL = \"https://tp.tax.gov.ir\")\n {\n this.PublicKey = publicKey;\n this.PrivateKey = privateKey;\n this.OrgKeyId = orgKeyId;",
"score": 0.8444209098815918
},
{
"filename": "Services/EncryptionService.cs",
"retrieved_chunk": "using System;\nusing System.Security.Cryptography;\nusing System.Text;\nnamespace Moadian.Services\n{\n public class EncryptionService\n {\n private const string CIPHER = \"aes-256-gcm\";\n private const int TAG_LENGTH = 16;\n private readonly RSA taxOrgPublicKey;",
"score": 0.81712406873703
},
{
"filename": "Dto/InvoiceHeaderDto.cs",
"retrieved_chunk": "namespace Moadian.Dto\n{\n public class InvoiceHeaderDto : PrimitiveDto\n {\n /**\n * unique tax ID (should be generated using InvoiceIdService)\n */\n public string taxid { get; set; }\n /**\n * invoice timestamp (milliseconds from epoch)",
"score": 0.8036051988601685
}
] | csharp | SignatureService signatureService, EncryptionService encryptionService, string baseUri = "https://tp.tax.gov.ir")
{ |
using HarmonyLib;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.ConstrainedExecution;
using UnityEngine;
namespace Ultrapain.Patches
{
class Drone_Start_Patch
{
static void Postfix(Drone __instance, ref EnemyIdentifier ___eid)
{
if (___eid.enemyType != EnemyType.Drone)
return;
__instance.gameObject.AddComponent<DroneFlag>();
}
}
class Drone_PlaySound_Patch
{
static FieldInfo antennaFlashField = typeof(Turret).GetField("antennaFlash", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
static ParticleSystem antennaFlash;
public static Color defaultLineColor = new Color(1f, 0.44f, 0.74f);
static bool Prefix(Drone __instance, EnemyIdentifier ___eid, AudioClip __0)
{
if (___eid.enemyType != EnemyType.Drone)
return true;
if(__0 == __instance.windUpSound)
{
DroneFlag flag = __instance.GetComponent<DroneFlag>();
if (flag == null)
return true;
List<Tuple<DroneFlag.Firemode, float>> chances = new List<Tuple<DroneFlag.Firemode, float>>();
if (ConfigManager.droneProjectileToggle.value)
chances.Add(new Tuple<DroneFlag.Firemode, float>(DroneFlag.Firemode.Projectile, ConfigManager.droneProjectileChance.value));
if (ConfigManager.droneExplosionBeamToggle.value)
chances.Add(new Tuple<DroneFlag.Firemode, float>(DroneFlag.Firemode.Explosive, ConfigManager.droneExplosionBeamChance.value));
if (ConfigManager.droneSentryBeamToggle.value)
chances.Add(new Tuple<DroneFlag.Firemode, float>(DroneFlag.Firemode.TurretBeam, ConfigManager.droneSentryBeamChance.value));
if (chances.Count == 0 || chances.Sum(item => item.Item2) <= 0)
flag.currentMode = DroneFlag.Firemode.Projectile;
else
flag.currentMode = UnityUtils.GetRandomFloatWeightedItem(chances, item => item.Item2).Item1;
if (flag.currentMode == DroneFlag.Firemode.Projectile)
{
flag.attackDelay = ConfigManager.droneProjectileDelay.value;
return true;
}
else if (flag.currentMode == DroneFlag.Firemode.Explosive)
{
flag.attackDelay = ConfigManager.droneExplosionBeamDelay.value;
GameObject chargeEffect = GameObject.Instantiate(Plugin.chargeEffect, __instance.transform);
chargeEffect.transform.localPosition = new Vector3(0, 0, 0.8f);
chargeEffect.transform.localScale = Vector3.zero;
float duration = ConfigManager.droneExplosionBeamDelay.value / ___eid.totalSpeedModifier;
RemoveOnTime remover = chargeEffect.AddComponent<RemoveOnTime>();
remover.time = duration;
CommonLinearScaler scaler = chargeEffect.AddComponent<CommonLinearScaler>();
scaler.targetTransform = scaler.transform;
scaler.scaleSpeed = 1f / duration;
CommonAudioPitchScaler pitchScaler = chargeEffect.AddComponent<CommonAudioPitchScaler>();
pitchScaler.targetAud = chargeEffect.GetComponent<AudioSource>();
pitchScaler.scaleSpeed = 1f / duration;
return false;
}
else if (flag.currentMode == DroneFlag.Firemode.TurretBeam)
{
flag.attackDelay = ConfigManager.droneSentryBeamDelay.value;
if(ConfigManager.droneDrawSentryBeamLine.value)
{
flag.lr.enabled = true;
flag.SetLineColor(ConfigManager.droneSentryBeamLineNormalColor.value);
flag.Invoke("LineRendererColorToWarning", Mathf.Max(0.01f, (flag.attackDelay / ___eid.totalSpeedModifier) - ConfigManager.droneSentryBeamLineIndicatorDelay.value));
}
if (flag.particleSystem == null)
{
if (antennaFlash == null)
antennaFlash = (ParticleSystem)antennaFlashField.GetValue(Plugin.turret);
flag.particleSystem = GameObject.Instantiate(antennaFlash, __instance.transform);
flag.particleSystem.transform.localPosition = new Vector3(0, 0, 2);
}
flag.particleSystem.Play();
GameObject flash = GameObject.Instantiate(Plugin.turretFinalFlash, __instance.transform);
GameObject.Destroy(flash.transform.Find("MuzzleFlash/muzzleflash").gameObject);
return false;
}
}
return true;
}
}
class Drone_Shoot_Patch
{
static bool Prefix(Drone __instance, ref EnemyIdentifier ___eid)
{
DroneFlag flag = __instance.GetComponent<DroneFlag>();
if(flag == null || __instance.crashing)
return true;
DroneFlag.Firemode mode = flag.currentMode;
if (mode == DroneFlag.Firemode.Projectile)
return true;
if (mode == DroneFlag.Firemode.Explosive)
{
GameObject beam = GameObject.Instantiate(Plugin.beam.gameObject, __instance.transform.position + __instance.transform.forward, __instance.transform.rotation);
RevolverBeam revBeam = beam.GetComponent<RevolverBeam>();
revBeam.hitParticle = Plugin.shotgunGrenade.gameObject.GetComponent<Grenade>().explosion;
revBeam.damage /= 2;
revBeam.damage *= ___eid.totalDamageModifier;
return false;
}
if(mode == DroneFlag.Firemode.TurretBeam)
{
GameObject turretBeam = GameObject.Instantiate(Plugin.turretBeam.gameObject, __instance.transform.position + __instance.transform.forward * 2f, __instance.transform.rotation);
if (turretBeam.TryGetComponent<RevolverBeam>(out RevolverBeam revBeam))
{
revBeam.damage = ConfigManager.droneSentryBeamDamage.value;
revBeam.damage *= ___eid.totalDamageModifier;
revBeam.alternateStartPoint = __instance.transform.position + __instance.transform.forward;
revBeam.ignoreEnemyType = EnemyType.Drone;
}
flag.lr.enabled = false;
return false;
}
Debug.LogError($"Drone fire mode in impossible state. Current value: {mode} : {(int)mode}");
return true;
}
}
class Drone_Update
{
static void Postfix(Drone __instance, EnemyIdentifier ___eid, ref float ___attackCooldown, int ___difficulty)
{
if (___eid.enemyType != EnemyType.Drone)
return;
DroneFlag flag = __instance.GetComponent<DroneFlag>();
if (flag == null || flag.attackDelay < 0)
return;
float attackSpeedDecay = (float)(___difficulty / 2);
if (___difficulty == 1)
{
attackSpeedDecay = 0.75f;
}
else if (___difficulty == 0)
{
attackSpeedDecay = 0.5f;
}
attackSpeedDecay *= ___eid.totalSpeedModifier;
float delay = flag.attackDelay / ___eid.totalSpeedModifier;
__instance.CancelInvoke("Shoot");
__instance.Invoke("Shoot", delay);
___attackCooldown = UnityEngine.Random.Range(2f, 4f) + (flag.attackDelay - 0.75f) * attackSpeedDecay;
flag.attackDelay = -1;
}
}
class DroneFlag : MonoBehaviour
{
public enum Firemode : int
{
Projectile = 0,
Explosive,
TurretBeam
}
public ParticleSystem particleSystem;
public LineRenderer lr;
public Firemode currentMode = Firemode.Projectile;
private static Firemode[] allModes = Enum.GetValues(typeof(Firemode)) as Firemode[];
static FieldInfo turretAimLine = typeof(Turret).GetField("aimLine", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
static Material whiteMat;
public void Awake()
{
lr = gameObject.AddComponent<LineRenderer>();
lr.enabled = false;
lr.receiveShadows = false;
lr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
lr.startWidth = lr.endWidth = lr.widthMultiplier = 0.025f;
if (whiteMat == null)
whiteMat = ((LineRenderer)turretAimLine.GetValue(Plugin.turret)).material;
lr.material = whiteMat;
}
public void SetLineColor(Color c)
{
Gradient gradient = new Gradient();
GradientColorKey[] array = new GradientColorKey[1];
array[0].color = c;
GradientAlphaKey[] array2 = new GradientAlphaKey[1];
array2[0].alpha = 1f;
gradient.SetKeys(array, array2);
lr.colorGradient = gradient;
}
public void LineRendererColorToWarning()
{
SetLineColor(ConfigManager.droneSentryBeamLineWarningColor.value);
}
public float attackDelay = -1;
public bool homingTowardsPlayer = false;
| Transform target; |
Rigidbody rb;
private void Update()
{
if(homingTowardsPlayer)
{
if(target == null)
target = PlayerTracker.Instance.GetTarget();
if (rb == null)
rb = GetComponent<Rigidbody>();
Quaternion to = Quaternion.LookRotation(target.position/* + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity()*/ - transform.position);
transform.rotation = Quaternion.RotateTowards(transform.rotation, to, Time.deltaTime * ConfigManager.droneHomeTurnSpeed.value);
rb.velocity = transform.forward * rb.velocity.magnitude;
}
if(lr.enabled)
{
lr.SetPosition(0, transform.position);
lr.SetPosition(1, transform.position + transform.forward * 1000);
}
}
}
class Drone_Death_Patch
{
static bool Prefix(Drone __instance, EnemyIdentifier ___eid)
{
if (___eid.enemyType != EnemyType.Drone || __instance.crashing)
return true;
DroneFlag flag = __instance.GetComponent<DroneFlag>();
if (flag == null)
return true;
if (___eid.hitter == "heavypunch" || ___eid.hitter == "punch")
return true;
flag.homingTowardsPlayer = true;
return true;
}
}
class Drone_GetHurt_Patch
{
static bool Prefix(Drone __instance, EnemyIdentifier ___eid, bool ___parried)
{
if((___eid.hitter == "shotgunzone" || ___eid.hitter == "punch") && !___parried)
{
DroneFlag flag = __instance.GetComponent<DroneFlag>();
if (flag == null)
return true;
flag.homingTowardsPlayer = false;
}
return true;
}
}
}
| Ultrapain/Patches/Drone.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Stray.cs",
"retrieved_chunk": " public GameObject standardProjectile;\n public GameObject standardDecorativeProjectile;\n public int comboRemaining = ConfigManager.strayShootCount.value;\n public bool inCombo = false;\n public float lastSpeed = 1f;\n public enum AttackMode\n {\n ProjectileCombo,\n FastHoming\n }",
"score": 0.834259033203125
},
{
"filename": "Ultrapain/Patches/PlayerStatTweaks.cs",
"retrieved_chunk": " {\n enabled = SceneHelper.CurrentLevelNumber > 0;\n }\n }\n public void ResetCooldown()\n {\n deltaCooldown = ConfigManager.playerHpDeltaDelay.value;\n }\n public float deltaCooldown = ConfigManager.playerHpDeltaDelay.value;\n public void Update()",
"score": 0.8334628343582153
},
{
"filename": "Ultrapain/Patches/V2First.cs",
"retrieved_chunk": " public Collider v2collider;\n public float punchCooldown = 0f;\n public Transform targetGrenade;\n void Update()\n {\n if (punchCooldown > 0)\n punchCooldown = Mathf.MoveTowards(punchCooldown, 0f, Time.deltaTime);\n }\n public void PunchShockwave()\n {",
"score": 0.8283324241638184
},
{
"filename": "Ultrapain/Patches/V2Common.cs",
"retrieved_chunk": " public Vector3 shootPoint;\n public Vector3 targetPoint;\n public RaycastHit targetHit;\n public bool alreadyHitPlayer = false;\n public bool alreadyReflected = false;\n private void Awake()\n {\n proj = GetComponent<Projectile>();\n proj.speed = 0;\n GetComponent<Rigidbody>().isKinematic = true;",
"score": 0.8263633847236633
},
{
"filename": "Ultrapain/Patches/V2Second.cs",
"retrieved_chunk": " //readonly static FieldInfo maliciousIgnorePlayer = typeof(RevolverBeam).GetField(\"maliciousIgnorePlayer\", BindingFlags.NonPublic | BindingFlags.Instance);\n Transform shootPoint;\n public Transform v2trans;\n public float cooldown = 0f;\n static readonly string debugTag = \"[V2][MalCannonShoot]\";\n void Awake()\n {\n shootPoint = UnityUtils.GetChildByNameRecursively(transform, \"Shootpoint\");\n }\n void PrepareFire()",
"score": 0.8230550289154053
}
] | csharp | Transform target; |
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using WindowsHook;
using wingman.Interfaces;
using static wingman.Helpers.KeyConverter;
namespace wingman.Services
{
public class KeyCombination
{
public Keys KeyCode { get; }
public | ModifierKeys Modifiers { | get; }
public KeyCombination OriginalRecord { get; }
public KeyCombination(Keys keyCode, ModifierKeys modifiers)
{
KeyCode = keyCode;
Modifiers = modifiers;
OriginalRecord = null;
}
public KeyCombination(Keys keyCode, ModifierKeys modifiers, KeyCombination originalRecord)
{
KeyCode = keyCode;
Modifiers = modifiers;
OriginalRecord = originalRecord;
}
public override bool Equals(object obj)
{
return obj is KeyCombination other && KeyCode == other.KeyCode && Modifiers == other.Modifiers;
}
public static bool operator ==(KeyCombination left, KeyCombination right)
{
if (left is null) return right is null;
return left.Equals(right);
}
public static bool operator !=(KeyCombination left, KeyCombination right)
{
return !(left == right);
}
public override int GetHashCode()
{
return HashCode.Combine(KeyCode, Modifiers);
}
}
public enum HotkeyType
{
KeyDown,
KeyUp
}
public class GlobalHotkeyService : IGlobalHotkeyService
{
private readonly IKeyboardMouseEvents _hook;
private readonly Dictionary<WingmanSettings, EventHandler> _hotkeyUpHandlers;
private readonly Dictionary<WingmanSettings, EventHandler> _hotkeyDownHandlers;
private readonly ISettingsService _settingsService;
private readonly Dictionary<HotkeyType, KeyCombination> _cachedValidHotkeys;
private readonly HashSet<KeyCombination> _currentlyPressedCombinations;
public GlobalHotkeyService(ISettingsService settingsService)
{
_hook = Hook.GlobalEvents();
_hotkeyUpHandlers = new Dictionary<WingmanSettings, EventHandler>();
_hotkeyDownHandlers = new Dictionary<WingmanSettings, EventHandler>();
_settingsService = settingsService;
_currentlyPressedKeys = new HashSet<Keys>();
_cachedValidHotkeys = new Dictionary<HotkeyType, KeyCombination>();
_currentlyPressedCombinations = new HashSet<KeyCombination>();
_hook.KeyDown += Hook_KeyDown;
_hook.KeyUp += Hook_KeyUp;
}
public void UpdateHotkeyCache() // could potentially speed up keyup/down events; not sure if it's worth it
{
foreach (var handlerEntry in _hotkeyUpHandlers)
{
WingmanSettings settingsKey = handlerEntry.Key;
var hotkeyStr = _settingsService.Load<string>(settingsKey);
var hotkeyCombination = ParseHotkeyCombination(hotkeyStr);
_cachedValidHotkeys[HotkeyType.KeyUp] = hotkeyCombination;
}
foreach (var handlerEntry in _hotkeyDownHandlers)
{
WingmanSettings settingsKey = handlerEntry.Key;
var hotkeyStr = _settingsService.Load<string>(settingsKey);
var hotkeyCombination = ParseHotkeyCombination(hotkeyStr);
_cachedValidHotkeys[HotkeyType.KeyDown] = hotkeyCombination;
}
}
public void RegisterHotkeyUp(WingmanSettings settingsKey, EventHandler handler)
{
if (!_hotkeyUpHandlers.ContainsKey(settingsKey))
{
_hotkeyUpHandlers[settingsKey] = null;
}
_hotkeyUpHandlers[settingsKey] += handler;
}
public void RegisterHotkeyDown(WingmanSettings settingsKey, EventHandler handler)
{
if (!_hotkeyDownHandlers.ContainsKey(settingsKey))
{
_hotkeyDownHandlers[settingsKey] = null;
}
_hotkeyDownHandlers[settingsKey] += handler;
}
public void UnregisterHotkeyUp(WingmanSettings settingsKey, EventHandler handler)
{
if (_hotkeyUpHandlers.ContainsKey(settingsKey))
{
_hotkeyUpHandlers[settingsKey] -= handler;
}
}
public void UnregisterHotkeyDown(WingmanSettings settingsKey, EventHandler handler)
{
if (_hotkeyDownHandlers.ContainsKey(settingsKey))
{
_hotkeyDownHandlers[settingsKey] -= handler;
}
}
private void Hook_KeyDown(object sender, KeyEventArgs e)
{
if (!IsModifierKey(e.KeyCode))
{
var currentModifiers = GetCurrentModifiers(e);
var keyCombination = new KeyCombination(e.KeyCode, currentModifiers, new KeyCombination(e.KeyCode, currentModifiers));
_currentlyPressedCombinations.Add(keyCombination);
if (HandleKeyEvent(keyCombination, _hotkeyDownHandlers))
{
Console.WriteLine(String.Format("D: {0} has been handled with mods: {1}", e.KeyCode.ToString(), e.Modifiers.ToString()));
e.Handled = true;
}
else
{
_currentlyPressedCombinations.Remove(keyCombination);
}
}
else
{
// Ignore modifier keys by themselves
}
}
private void Hook_KeyUp(object sender, KeyEventArgs e)
{
if (!IsModifierKey(e.KeyCode))
{
var findPressed = _currentlyPressedCombinations.FirstOrDefault(x => x.KeyCode == e.KeyCode);
if (findPressed == null)
return;
_currentlyPressedCombinations.Remove(findPressed);
if (HandleKeyEvent(findPressed.OriginalRecord, _hotkeyUpHandlers))
{
e.Handled = true;
Debug.WriteLine(String.Format("UpX. {0} is handled.", e.KeyCode.ToString()));
}
}
}
// takes KeyCombination
private bool HandleKeyEvent(KeyCombination pressed, Dictionary<WingmanSettings, EventHandler> handlers)
{
bool isHandled = false;
foreach (var handlerEntry in handlers)
{
var settingsKey = handlerEntry.Key;
var handler = handlerEntry.Value;
var hotkeySettingString = _settingsService.Load<string>(settingsKey);
var hotkeyCombo = ParseHotkeyCombination(hotkeySettingString);
if (hotkeyCombo == pressed)
{
handler?.Invoke(this, EventArgs.Empty);
isHandled = true;
}
}
return isHandled;
}
private readonly Dictionary<string, Keys> specialKeysMap = new Dictionary<string, Keys>
{
{ "`", Keys.Oem3 },
{ ";", Keys.Oem1 },
{ "=", Keys.Oemplus },
{ ",", Keys.Oemcomma },
{ "-", Keys.OemMinus },
{ ".", Keys.OemPeriod },
{ "/", Keys.Oem2 },
{ "[", Keys.Oem4 },
{ "\\", Keys.Oem5 },
{ "]", Keys.Oem6 },
{ "'", Keys.Oem7 }
};
private KeyCombination ParseHotkeyCombination(string hotkeyCombination)
{
Keys newkey = Keys.None;
ModifierKeys modifiers = ModifierKeys.None;
if (hotkeyCombination.Length > 1 && hotkeyCombination.Contains('+'))
{
var keysAndModifiers = hotkeyCombination.Split("+");
var keystr = keysAndModifiers.TakeLast(1).Single().Trim();
Array.Resize(ref keysAndModifiers, keysAndModifiers.Length - 1);
newkey = specialKeysMap.ContainsKey(keystr) ? specialKeysMap[keystr] : (Keys)Enum.Parse(typeof(Keys), keystr, ignoreCase: true);
foreach (var modifier in keysAndModifiers)
{
// Check if the key is a modifier key
if (modifier == "Alt")
{
modifiers |= ModifierKeys.Alt;
}
else if (modifier == "Ctrl")
{
modifiers |= ModifierKeys.Control;
}
else if (modifier == "Shift")
{
modifiers |= ModifierKeys.Shift;
}
else if (modifier == "Win")
{
modifiers |= ModifierKeys.Windows;
}
}
}
else
{
modifiers = ModifierKeys.None;
newkey = specialKeysMap.ContainsKey(hotkeyCombination) ? specialKeysMap[hotkeyCombination] : (Keys)Enum.Parse(typeof(Keys), hotkeyCombination, ignoreCase: true);
}
// Create the key combination
return new KeyCombination(newkey, modifiers);
}
private ModifierKeys GetCurrentModifiers(KeyEventArgs e)
{
ModifierKeys currentModifiers = ModifierKeys.None;
if (e.Control) currentModifiers |= ModifierKeys.Control;
if (e.Shift) currentModifiers |= ModifierKeys.Shift;
if (e.Alt) currentModifiers |= ModifierKeys.Alt;
return currentModifiers;
}
// Start of Hotkey Configuration Routines
private Func<string, bool> _keyConfigurationCallback;
private readonly HashSet<Keys> _currentlyPressedKeys;
public async Task ConfigureHotkeyAsync(Func<string, bool> keyConfigurationCallback)
{
_currentlyPressedKeys.Clear();
_keyConfigurationCallback = keyConfigurationCallback;
// Unregister the original KeyDown and KeyUp listeners.
_hook.KeyDown -= Hook_KeyDown;
_hook.KeyUp -= Hook_KeyUp;
// Register the configuration KeyDown and KeyUp listeners.
_hook.KeyDown += Hook_KeyDown_Configuration;
_hook.KeyUp += Hook_KeyUp_Configuration;
while (_keyConfigurationCallback != null)
{
await Task.Delay(500);
}
// Unregister the configuration KeyDown and KeyUp listeners.
_hook.KeyDown -= Hook_KeyDown_Configuration;
_hook.KeyUp -= Hook_KeyUp_Configuration;
// Re-register the original KeyDown and KeyUp listeners.
_hook.KeyDown += Hook_KeyDown;
_hook.KeyUp += Hook_KeyUp;
}
private void Hook_KeyDown_Configuration(object sender, KeyEventArgs e)
{
if (!IsModifierKey(e.KeyCode))
{
_currentlyPressedKeys.Add(e.KeyCode);
}
ModifierKeys currentModifiers = ModifierKeys.None;
if (e.Control) currentModifiers |= ModifierKeys.Control;
if (e.Shift) currentModifiers |= ModifierKeys.Shift;
if (e.Alt) currentModifiers |= ModifierKeys.Alt;
var otherModifiers = GetCurrentModifiers(e);
if ((otherModifiers & ModifierKeys.Windows) != 0)
currentModifiers |= ModifierKeys.Windows;
if (!IsModifierKey(e.KeyCode))
{
var hkstr = BuildHotkeyString(e);
_keyConfigurationCallback?.Invoke(hkstr);
_keyConfigurationCallback = null;
e.Handled = true;
}
}
private void Hook_KeyUp_Configuration(object sender, KeyEventArgs e)
{
_currentlyPressedKeys.Remove(e.KeyCode);
}
private bool IsModifierKey(Keys keyCode)
{
return keyCode == Keys.ControlKey || keyCode == Keys.ShiftKey || keyCode == Keys.Menu || keyCode == Keys.LMenu || keyCode == Keys.RMenu
|| keyCode == Keys.LShiftKey || keyCode == Keys.RShiftKey || keyCode == Keys.LControlKey || keyCode == Keys.RControlKey || keyCode == Keys.LWin || keyCode == Keys.RWin;
}
private string BuildHotkeyString(KeyEventArgs e)
{
List<string> keyParts = new List<string>();
if (e.Control) keyParts.Add("Ctrl");
if (e.Shift) keyParts.Add("Shift");
if (e.Alt) keyParts.Add("Alt");
var otherModifiers = GetCurrentModifiers(e);
if ((otherModifiers & ModifierKeys.Windows) != 0)
keyParts.Add("Win");
string mainKey = specialKeysMap.FirstOrDefault(x => x.Value == e.KeyCode).Key;
if (string.IsNullOrEmpty(mainKey))
{
mainKey = e.KeyCode.ToString();
}
keyParts.Add(mainKey);
return string.Join("+", keyParts);
}
}
}
| Services/GlobalHotkeyService.cs | dannyr-git-wingman-41103f3 | [
{
"filename": "Helpers/KeyConverter.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing Windows.System;\nusing Windows.UI.Input.Preview.Injection;\nnamespace wingman.Helpers\n{\n public static class KeyConverter\n {\n [Flags]\n public enum ModifierKeys",
"score": 0.872771143913269
},
{
"filename": "App.xaml.cs",
"retrieved_chunk": "using wingman.ViewModels;\nusing wingman.Views;\nnamespace wingman\n{\n public partial class App : Application, IDisposable\n {\n private readonly IHost _host;\n private readonly AppUpdater _appUpdater;\n public App()\n {",
"score": 0.8354051113128662
},
{
"filename": "Services/AppActivationService.cs",
"retrieved_chunk": "using System;\nusing System.Diagnostics;\nusing wingman.Interfaces;\nusing wingman.Views;\nnamespace wingman.Services\n{\n public class AppActivationService : IAppActivationService, IDisposable\n {\n private readonly MainWindow _mainWindow;\n private readonly ISettingsService _settingsService;",
"score": 0.8196509480476379
},
{
"filename": "Views/Controls/ModalControl.xaml.cs",
"retrieved_chunk": "using CommunityToolkit.Mvvm.DependencyInjection;\nusing Microsoft.UI.Xaml.Controls;\nusing wingman.ViewModels;\nnamespace wingman.Views\n{\n public sealed partial class ModalControl : UserControl\n {\n public ModalControl()\n {\n InitializeComponent();",
"score": 0.8056580424308777
},
{
"filename": "Views/MainPage.xaml.cs",
"retrieved_chunk": "using CommunityToolkit.Mvvm.DependencyInjection;\nusing Microsoft.UI.Xaml.Controls;\nusing wingman.ViewModels;\nnamespace wingman.Views\n{\n public sealed partial class MainPage : Page\n {\n public MainPage()\n {\n InitializeComponent();",
"score": 0.8030121326446533
}
] | csharp | ModifierKeys Modifiers { |
using CommunityToolkit.Mvvm.ComponentModel;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls.Primitives;
using System;
using wingman.Interfaces;
using wingman.Services;
namespace wingman.ViewModels
{
public class OpenAIControlViewModel : ObservableObject
{
private readonly ISettingsService _settingsService;
private readonly IGlobalHotkeyService _globalHotkeyService;
private readonly ILoggingService _logger;
private string _apikey;
private bool _keypressed;
private string _mainhotkey;
private string _modalhotkey;
private string _purgatoryhotkey;
private bool _trimwhitespaces;
private bool _trimnewlines;
private bool _appendclipboard;
private bool _appendclipboardmodal;
public OpenAIControlViewModel(ISettingsService settingsService, | IOpenAIAPIService openAIService, IGlobalHotkeyService globalHotkeyService, ILoggingService logger)
{ |
_settingsService = settingsService;
_globalHotkeyService = globalHotkeyService;
_logger = logger;
Main_Hotkey_Toggled = false;
Api_Key = _settingsService.Load<string>(WingmanSettings.ApiKey);
Main_Hotkey = _settingsService.Load<string>(WingmanSettings.Main_Hotkey);
Modal_Hotkey = _settingsService.Load<string>(WingmanSettings.Modal_Hotkey);
Trim_Newlines = _settingsService.Load<bool>(WingmanSettings.Trim_Newlines);
Trim_Whitespaces = _settingsService.Load<bool>(WingmanSettings.Trim_Whitespaces);
Append_Clipboard = _settingsService.Load<bool>(WingmanSettings.Append_Clipboard);
Append_Clipboard_Modal = _settingsService.Load<bool>(WingmanSettings.Append_Clipboard_Modal);
}
public bool Append_Clipboard_Modal
{
get => _appendclipboardmodal;
set
{
_settingsService.Save<bool>(WingmanSettings.Append_Clipboard_Modal, value);
SetProperty(ref _appendclipboardmodal, value);
}
}
public bool Append_Clipboard
{
get => _appendclipboard;
set
{
_settingsService.Save<bool>(WingmanSettings.Append_Clipboard, value);
SetProperty(ref _appendclipboard, value);
}
}
public bool Trim_Whitespaces
{
get => _trimwhitespaces;
set
{
_settingsService.Save<bool>(WingmanSettings.Trim_Whitespaces, value);
SetProperty(ref _trimwhitespaces, value);
}
}
public bool Trim_Newlines
{
get => _trimnewlines;
set
{
_settingsService.Save<bool>(WingmanSettings.Trim_Newlines, value);
SetProperty(ref _trimnewlines, value);
}
}
public string Main_Hotkey
{
get => _mainhotkey;
set
{
_settingsService.Save(WingmanSettings.Main_Hotkey, value); // TODO; actually manage hotkey key,value pair relationships
SetProperty(ref _mainhotkey, value);
}
}
public string Modal_Hotkey
{
get => _modalhotkey;
set
{
_settingsService.Save(WingmanSettings.Modal_Hotkey, value);
SetProperty(ref _modalhotkey, value);
}
}
public bool Main_Hotkey_Toggled
{
get => _keypressed;
set => SetProperty(ref _keypressed, value);
}
public async void ConfigureHotkeyCommand(object sender, RoutedEventArgs e)
{
Main_Hotkey_Toggled = true;
await _globalHotkeyService.ConfigureHotkeyAsync(NativeKeyboard_OnKeyDown);
Main_Hotkey_Toggled = false;
if (!String.IsNullOrEmpty(_purgatoryhotkey))
{
// try to clear sticky keys
if ((sender as ToggleButton).Name == "ConfigMainHotkeyButton")
{
if (_purgatoryhotkey != Modal_Hotkey)
Main_Hotkey = _purgatoryhotkey;
else
_logger.LogError("Main hotkey cannot be the same as the modal hotkey.");
}
else if ((sender as ToggleButton).Name == "ConfigModalHotkeyButton")
{
if (_purgatoryhotkey != Main_Hotkey)
Modal_Hotkey = _purgatoryhotkey;
else
_logger.LogError("Modal hotkey cannot be the same as the main hotkey.");
}
}
}
private bool NativeKeyboard_OnKeyDown(string input)
{
if (input == "Escape" || String.IsNullOrEmpty(input))
{
_purgatoryhotkey = "";
return true;
}
Main_Hotkey_Toggled = false;
_purgatoryhotkey = input;
return true;
}
public bool IsValidKey()
{
return _isvalidkey;
}
bool _isvalidkey;
public bool IsEnabled
{
get => _isvalidkey;
set
{
SetProperty(ref _isvalidkey, value);
}
}
private bool IsApiKeyValid()
{
if (String.IsNullOrEmpty(_apikey) || !_apikey.StartsWith("sk-") || _apikey.Length != 51)
return false;
return true;
}
private readonly string _apikeymessage;
public string ApiKeymessage
{
get
{
if (IsApiKeyValid())
return "Key format valid.";
else
return "Invalid key format.";
}
}
public string Api_Key
{
get => _apikey;
set
{
SetProperty(ref _apikey, value);
if (!IsApiKeyValid())
{
_apikey = "You must enter a valid OpenAI API Key.";
IsEnabled = IsApiKeyValid();
OnPropertyChanged(nameof(Api_Key));
}
else
{
_settingsService.TrySave(WingmanSettings.ApiKey, value);
IsEnabled = IsApiKeyValid();
_logger.LogInfo("New OpenAI key has a valid format.");
}
OnPropertyChanged(nameof(ApiKeymessage));
}
}
}
} | ViewModels/OpenAIControlViewModel.cs | dannyr-git-wingman-41103f3 | [
{
"filename": "Services/EventHandlerService.cs",
"retrieved_chunk": " private readonly OpenAIControlViewModel openAIControlViewModel;\n private readonly MediaPlayer mediaPlayer;\n private readonly Stopwatch micQueueDebouncer = new Stopwatch();\n private bool isDisposed;\n private bool isRecording;\n private bool isProcessing;\n public EventHandler<bool> InferenceCallback { get; set; }\n public EventHandlerService(OpenAIControlViewModel openAIControlViewModel,\n IGlobalHotkeyService globalHotkeyService,\n IMicrophoneDeviceService micService,",
"score": 0.8203840255737305
},
{
"filename": "Services/GlobalHotkeyService.cs",
"retrieved_chunk": " public class GlobalHotkeyService : IGlobalHotkeyService\n {\n private readonly IKeyboardMouseEvents _hook;\n private readonly Dictionary<WingmanSettings, EventHandler> _hotkeyUpHandlers;\n private readonly Dictionary<WingmanSettings, EventHandler> _hotkeyDownHandlers;\n private readonly ISettingsService _settingsService;\n private readonly Dictionary<HotkeyType, KeyCombination> _cachedValidHotkeys;\n private readonly HashSet<KeyCombination> _currentlyPressedCombinations;\n public GlobalHotkeyService(ISettingsService settingsService)\n {",
"score": 0.819693922996521
},
{
"filename": "ViewModels/MainPageViewModel.cs",
"retrieved_chunk": "{\n public class MainPageViewModel : ObservableObject\n {\n private readonly IEditorService _editorService;\n private readonly IStdInService _stdinService;\n private readonly ISettingsService _settingsService;\n private readonly ILoggingService _loggingService;\n private List<string> _stdInTargetOptions = new List<string>();\n private List<Process> _runningProcesses;\n // Selected values",
"score": 0.8150153160095215
},
{
"filename": "ViewModels/FooterViewModel.cs",
"retrieved_chunk": " {\n private readonly ISettingsService _settingsService;\n private readonly ILoggingService _loggingService;\n private readonly DispatcherQueue _dispatcherQueue;\n private readonly EventHandler<string> LoggingService_OnLogEntry;\n private string _logText = \"\";\n private bool _disposed = false;\n private bool _disposing = false;\n public FooterViewModel(ISettingsService settingsService, ILoggingService loggingService)\n {",
"score": 0.8124006986618042
},
{
"filename": "Services/OpenAIAPIService.cs",
"retrieved_chunk": " private readonly ISettingsService settingsService;\n private readonly ILoggingService Logger;\n private readonly string _apikey;\n private readonly bool _disposed;\n public OpenAIAPIService(ISettingsService settingsService, ILoggingService logger)\n {\n this.settingsService = settingsService;\n this.Logger = logger;\n _apikey = settingsService.Load<string>(WingmanSettings.ApiKey);\n if (String.IsNullOrEmpty(_apikey))",
"score": 0.8002657890319824
}
] | csharp | IOpenAIAPIService openAIService, IGlobalHotkeyService globalHotkeyService, ILoggingService logger)
{ |
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Net.Http;
using System.Threading;
namespace HttpMessageHandlerFactory.Implementations
{
/// <summary>
/// 默认的Http消息处理者工厂
/// </summary>
sealed class DefaultHttpMessageHandlerFactory : IHttpMessageHandlerFactory
{
private readonly NameRegistration nameRegistration;
private readonly IServiceScopeFactory serviceScopeFactory;
private readonly | ExpiredHandlerEntryCleaner expiredHandlerEntryCleaner; |
/// <summary>
/// 过期回调
/// </summary>
private readonly TimerCallback expiryCallback;
/// <summary>
/// LazyOf(ActiveHandlerEntry)缓存
/// </summary>
private readonly ConcurrentDictionary<NameProxy, Lazy<ActiveHandlerEntry>> activeHandlerEntries = new();
/// <summary>
/// Http消息处理者工厂
/// </summary>
/// <param name="nameRegistration"></param>
/// <param name="serviceScopeFactory"></param>
/// <param name="expiredHandlerEntryCleaner"></param>
public DefaultHttpMessageHandlerFactory(
NameRegistration nameRegistration,
IServiceScopeFactory serviceScopeFactory,
ExpiredHandlerEntryCleaner expiredHandlerEntryCleaner)
{
this.nameRegistration = nameRegistration;
this.serviceScopeFactory = serviceScopeFactory;
this.expiredHandlerEntryCleaner = expiredHandlerEntryCleaner;
this.expiryCallback = this.ExpiryTimer_Tick;
}
/// <summary>
/// 创建用于请求的HttpMessageHandler
/// </summary>
/// <param name="name">别名</param>
/// <param name="proxyUri">支持携带UserInfo的代理地址</param>
/// <returns></returns>
public HttpMessageHandler CreateHandler(string name, Uri? proxyUri)
{
if (this.nameRegistration.Contains(name) == false)
{
throw new InvalidOperationException($"尚未登记别名为 {name} 的HttpMessageHandler");
}
var nameProxy = new NameProxy(name, proxyUri);
var ativeEntry = this.activeHandlerEntries.GetOrAdd(nameProxy, this.CreateActiveHandlerEntryLazy).Value;
ativeEntry.StartExpiryTimer(this.expiryCallback);
return ativeEntry.LifetimeHttpHandler;
}
/// <summary>
/// 创建LazyOf(ActiveHandlerEntry)
/// </summary>
/// <param name="nameProxy"></param>
/// <returns></returns>
private Lazy<ActiveHandlerEntry> CreateActiveHandlerEntryLazy(NameProxy nameProxy)
{
return new Lazy<ActiveHandlerEntry>(() => this.CreateActiveHandlerEntry(nameProxy), LazyThreadSafetyMode.ExecutionAndPublication);
}
/// <summary>
/// 创建ActiveHandlerEntry
/// </summary>
/// <param name="nameProxy"></param>
/// <returns></returns>
private ActiveHandlerEntry CreateActiveHandlerEntry(NameProxy nameProxy)
{
var serviceScope = this.serviceScopeFactory.CreateScope();
var serviceProvider = serviceScope.ServiceProvider;
var builder = serviceProvider.GetRequiredService<HttpMessageHandlerBuilder>();
builder.NameProxy = nameProxy;
var httpHandler = builder.Build();
var lifetime = builder.GetLifetime();
var lifeTimeHandler = new LifetimeHttpHandler(httpHandler);
return new ActiveHandlerEntry(lifetime, nameProxy, serviceScope, lifeTimeHandler);
}
/// <summary>
/// 过期timer回调
/// </summary>
/// <param name="state"></param>
private void ExpiryTimer_Tick(object? state)
{
var ativeEntry = (ActiveHandlerEntry)state!;
// The timer callback should be the only one removing from the active collection. If we can't find
// our entry in the collection, then this is a bug.
var removed = this.activeHandlerEntries.TryRemove(ativeEntry.NameProxy, out Lazy<ActiveHandlerEntry>? found);
Debug.Assert(removed, "Entry not found. We should always be able to remove the entry");
Debug.Assert(object.ReferenceEquals(ativeEntry, found!.Value), "Different entry found. The entry should not have been replaced");
// At this point the handler is no longer 'active' and will not be handed out to any new clients.
// However we haven't dropped our strong reference to the handler, so we can't yet determine if
// there are still any other outstanding references (we know there is at least one).
// We use a different state object to track expired handlers. This allows any other thread that acquired
// the 'active' entry to use it without safety problems.
var expiredEntry = new ExpiredHandlerEntry(ativeEntry);
this.expiredHandlerEntryCleaner.Add(expiredEntry);
}
}
}
| HttpMessageHandlerFactory/Implementations/DefaultHttpMessageHandlerFactory.cs | xljiulang-HttpMessageHandlerFactory-4b1d13b | [
{
"filename": "HttpMessageHandlerFactory/Implementations/HttpMessageHandlerBuilder.cs",
"retrieved_chunk": " sealed class HttpMessageHandlerBuilder\n {\n private readonly IServiceProvider serviceProvider;\n private readonly IOptionsMonitor<HttpMessageHandlerOptions> options;\n /// <summary>\n /// 获取或设置别名和代理\n /// </summary>\n [NotNull]\n public NameProxy? NameProxy { get; set; }\n /// <summary>",
"score": 0.8654659390449524
},
{
"filename": "HttpMessageHandlerFactory/Implementations/ExpiredHandlerEntry.cs",
"retrieved_chunk": " {\n private readonly WeakReference livenessTracker;\n public bool CanDispose => !livenessTracker.IsAlive;\n public NameProxy NameProxy { get; }\n public IServiceScope ServiceScope { get; }\n /// <summary>\n /// LifetimeHttpHandler的InnerHandler\n /// </summary>\n public HttpMessageHandler InnerHandler { get; }\n /// <summary>",
"score": 0.863754153251648
},
{
"filename": "HttpMessageHandlerFactory/DependencyInjection/IHttpMessageHandlerBuilder.cs",
"retrieved_chunk": "namespace Microsoft.Extensions.DependencyInjection\n{\n /// <summary>\n /// Http消息处理者创建者\n /// </summary>\n public interface IHttpMessageHandlerBuilder\n {\n /// <summary>\n /// 选项名\n /// </summary>",
"score": 0.8598325252532959
},
{
"filename": "HttpMessageHandlerFactory/IHttpMessageHandlerFactory.cs",
"retrieved_chunk": "using System;\nusing System.Net.Http;\nnamespace HttpMessageHandlerFactory\n{\n /// <summary>\n /// Http消息处理者工厂\n /// </summary>\n public interface IHttpMessageHandlerFactory\n {\n /// <summary>",
"score": 0.8545713424682617
},
{
"filename": "HttpMessageHandlerFactory/Implementations/LifetimeHttpHandler.cs",
"retrieved_chunk": "using System.Net.Http;\nnamespace HttpMessageHandlerFactory.Implementations\n{\n /// <summary>\n /// 表示自主管理生命周期的的HttpMessageHandler\n /// </summary>\n sealed class LifetimeHttpHandler : DelegatingHandler\n {\n /// <summary>\n /// 具有生命周期的HttpHandler",
"score": 0.8514218330383301
}
] | csharp | ExpiredHandlerEntryCleaner expiredHandlerEntryCleaner; |
using BepInEx;
using UnityEngine;
using UnityEngine.SceneManagement;
using System;
using HarmonyLib;
using System.IO;
using Ultrapain.Patches;
using System.Linq;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Reflection;
using Steamworks;
using Unity.Audio;
using System.Text;
using System.Collections.Generic;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.UIElements;
using PluginConfig.API;
namespace Ultrapain
{
[BepInPlugin(PLUGIN_GUID, PLUGIN_NAME, PLUGIN_VERSION)]
[BepInDependency("com.eternalUnion.pluginConfigurator", "1.6.0")]
public class Plugin : BaseUnityPlugin
{
public const string PLUGIN_GUID = "com.eternalUnion.ultraPain";
public const string PLUGIN_NAME = "Ultra Pain";
public const string PLUGIN_VERSION = "1.1.0";
public static Plugin instance;
private static bool addressableInit = false;
public static T LoadObject<T>(string path)
{
if (!addressableInit)
{
Addressables.InitializeAsync().WaitForCompletion();
addressableInit = true;
}
return Addressables.LoadAssetAsync<T>(path).WaitForCompletion();
}
public static Vector3 PredictPlayerPosition(Collider safeCollider, float speedMod)
{
Transform target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
return target.position;
RaycastHit raycastHit;
if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == safeCollider)
return target.position;
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
return raycastHit.point;
}
else {
Vector3 projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
return new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
}
public static GameObject projectileSpread;
public static GameObject homingProjectile;
public static GameObject hideousMassProjectile;
public static GameObject decorativeProjectile2;
public static GameObject shotgunGrenade;
public static GameObject beam;
public static GameObject turretBeam;
public static GameObject lightningStrikeExplosiveSetup;
public static GameObject lightningStrikeExplosive;
public static GameObject lighningStrikeWindup;
public static GameObject explosion;
public static GameObject bigExplosion;
public static GameObject sandExplosion;
public static GameObject virtueInsignia;
public static GameObject rocket;
public static GameObject revolverBullet;
public static GameObject maliciousCannonBeam;
public static GameObject lightningBoltSFX;
public static GameObject revolverBeam;
public static GameObject blastwave;
public static GameObject cannonBall;
public static GameObject shockwave;
public static GameObject sisyphiusExplosion;
public static GameObject sisyphiusPrimeExplosion;
public static GameObject explosionWaveKnuckleblaster;
public static GameObject chargeEffect;
public static GameObject maliciousFaceProjectile;
public static GameObject hideousMassSpear;
public static GameObject coin;
public static GameObject sisyphusDestroyExplosion;
//public static GameObject idol;
public static GameObject ferryman;
public static GameObject minosPrime;
//public static GameObject maliciousFace;
public static GameObject somethingWicked;
public static Turret turret;
public static GameObject turretFinalFlash;
public static GameObject enrageEffect;
public static GameObject v2flashUnparryable;
public static GameObject ricochetSfx;
public static GameObject parryableFlash;
public static | AudioClip cannonBallChargeAudio; |
public static Material gabrielFakeMat;
public static Sprite blueRevolverSprite;
public static Sprite greenRevolverSprite;
public static Sprite redRevolverSprite;
public static Sprite blueShotgunSprite;
public static Sprite greenShotgunSprite;
public static Sprite blueNailgunSprite;
public static Sprite greenNailgunSprite;
public static Sprite blueSawLauncherSprite;
public static Sprite greenSawLauncherSprite;
public static GameObject rocketLauncherAlt;
public static GameObject maliciousRailcannon;
// Variables
public static float SoliderShootAnimationStart = 1.2f;
public static float SoliderGrenadeForce = 10000f;
public static float SwordsMachineKnockdownTimeNormalized = 0.8f;
public static float SwordsMachineCoreSpeed = 80f;
public static float MinGrenadeParryVelocity = 40f;
public static GameObject _lighningBoltSFX;
public static GameObject lighningBoltSFX
{
get
{
if (_lighningBoltSFX == null)
_lighningBoltSFX = ferryman.gameObject.transform.Find("LightningBoltChimes").gameObject;
return _lighningBoltSFX;
}
}
private static bool loadedPrefabs = false;
public void LoadPrefabs()
{
if (loadedPrefabs)
return;
loadedPrefabs = true;
// Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab
projectileSpread = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab
homingProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab
decorativeProjectile2 = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab");
// Assets/Prefabs/Attacks and Projectiles/Grenade.prefab
shotgunGrenade = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Grenade.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab
turretBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
beam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab
lightningStrikeExplosiveSetup = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab");
// Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab
lighningStrikeWindup = LoadObject<GameObject>("Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab");
//[bundle-0][assets/prefabs/enemies/idol.prefab]
//idol = LoadObject<GameObject>("assets/prefabs/enemies/idol.prefab");
// Assets/Prefabs/Enemies/Ferryman.prefab
ferryman = LoadObject<GameObject>("Assets/Prefabs/Enemies/Ferryman.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab
explosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab
bigExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab
sandExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab");
// Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab
virtueInsignia = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab
hideousMassProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab");
// Assets/Particles/Enemies/RageEffect.prefab
enrageEffect = LoadObject<GameObject>("Assets/Particles/Enemies/RageEffect.prefab");
// Assets/Particles/Flashes/V2FlashUnparriable.prefab
v2flashUnparryable = LoadObject<GameObject>("Assets/Particles/Flashes/V2FlashUnparriable.prefab");
// Assets/Prefabs/Attacks and Projectiles/Rocket.prefab
rocket = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Rocket.prefab");
// Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab
revolverBullet = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab
maliciousCannonBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab
revolverBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab
blastwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab");
// Assets/Prefabs/Enemies/MinosPrime.prefab
minosPrime = LoadObject<GameObject>("Assets/Prefabs/Enemies/MinosPrime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab
cannonBall = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab");
// get from Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
cannonBallChargeAudio = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab").transform.Find("RocketLauncher/Armature/Body_Bone/HologramDisplay").GetComponent<AudioSource>().clip;
// Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab
shockwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab
sisyphiusExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab
sisyphiusPrimeExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab
explosionWaveKnuckleblaster = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab - [bundle-0][assets/prefabs/explosionlightning variant.prefab]
lightningStrikeExplosive = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab");
// Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
rocketLauncherAlt = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab");
// Assets/Prefabs/Weapons/Railcannon Malicious.prefab
maliciousRailcannon = LoadObject<GameObject>("Assets/Prefabs/Weapons/Railcannon Malicious.prefab");
//Assets/Particles/SoundBubbles/Ricochet.prefab
ricochetSfx = LoadObject<GameObject>("Assets/Particles/SoundBubbles/Ricochet.prefab");
//Assets/Particles/Flashes/Flash.prefab
parryableFlash = LoadObject<GameObject>("Assets/Particles/Flashes/Flash.prefab");
//Assets/Prefabs/Attacks and Projectiles/Spear.prefab
hideousMassSpear = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Spear.prefab");
//Assets/Prefabs/Enemies/Wicked.prefab
somethingWicked = LoadObject<GameObject>("Assets/Prefabs/Enemies/Wicked.prefab");
//Assets/Textures/UI/SingleRevolver.png
blueRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/SingleRevolver.png");
//Assets/Textures/UI/RevolverSpecial.png
greenRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSpecial.png");
//Assets/Textures/UI/RevolverSharp.png
redRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSharp.png");
//Assets/Textures/UI/Shotgun.png
blueShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun.png");
//Assets/Textures/UI/Shotgun1.png
greenShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun1.png");
//Assets/Textures/UI/Nailgun2.png
blueNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Nailgun2.png");
//Assets/Textures/UI/NailgunOverheat.png
greenNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/NailgunOverheat.png");
//Assets/Textures/UI/SawbladeLauncher.png
blueSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncher.png");
//Assets/Textures/UI/SawbladeLauncherOverheat.png
greenSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncherOverheat.png");
//Assets/Prefabs/Attacks and Projectiles/Coin.prefab
coin = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Coin.prefab");
//Assets/Materials/GabrielFake.mat
gabrielFakeMat = LoadObject<Material>("Assets/Materials/GabrielFake.mat");
//Assets/Prefabs/Enemies/Turret.prefab
turret = LoadObject<GameObject>("Assets/Prefabs/Enemies/Turret.prefab").GetComponent<Turret>();
//Assets/Particles/Flashes/GunFlashDistant.prefab
turretFinalFlash = LoadObject<GameObject>("Assets/Particles/Flashes/GunFlashDistant.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab
sisyphusDestroyExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab");
//Assets/Prefabs/Effects/Charge Effect.prefab
chargeEffect = LoadObject<GameObject>("Assets/Prefabs/Effects/Charge Effect.prefab");
//Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
maliciousFaceProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
}
public static bool ultrapainDifficulty = false;
public static bool realUltrapainDifficulty = false;
public static GameObject currentDifficultyButton;
public static GameObject currentDifficultyPanel;
public static Text currentDifficultyInfoText;
public void OnSceneChange(Scene before, Scene after)
{
StyleIDs.RegisterIDs();
ScenePatchCheck();
string mainMenuSceneName = "b3e7f2f8052488a45b35549efb98d902";
string bootSequenceSceneName = "4f8ecffaa98c2614f89922daf31fa22d";
string currentSceneName = SceneManager.GetActiveScene().name;
if (currentSceneName == mainMenuSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Difficulty Select (1)");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach(EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
else if(currentSceneName == bootSequenceSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Intro/Difficulty Select");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach (EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
// LOAD CUSTOM PREFABS HERE TO AVOID MID GAME LAG
MinosPrimeCharge.CreateDecoy();
GameObject shockwaveSisyphus = SisyphusInstructionist_Start.shockwave;
}
public static class StyleIDs
{
private static bool registered = false;
public static void RegisterIDs()
{
registered = false;
if (MonoSingleton<StyleHUD>.Instance == null)
return;
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.grenadeBoostStyleText.guid, ConfigManager.grenadeBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.rocketBoostStyleText.guid, ConfigManager.rocketBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverStyleText.guid, ConfigManager.orbStrikeRevolverStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverChargedStyleText.guid, ConfigManager.orbStrikeRevolverChargedStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeElectricCannonStyleText.guid, ConfigManager.orbStrikeElectricCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeMaliciousCannonStyleText.guid, ConfigManager.orbStrikeMaliciousCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.maliciousChargebackStyleText.guid, ConfigManager.maliciousChargebackStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.sentryChargebackStyleText.guid, ConfigManager.sentryChargebackStyleText.formattedString);
registered = true;
Debug.Log("Registered all style ids");
}
private static FieldInfo idNameDict = typeof(StyleHUD).GetField("idNameDict", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
public static void UpdateID(string id, string newName)
{
if (!registered || StyleHUD.Instance == null)
return;
(idNameDict.GetValue(StyleHUD.Instance) as Dictionary<string, string>)[id] = newName;
}
}
public static Harmony harmonyTweaks;
public static Harmony harmonyBase;
private static MethodInfo GetMethod<T>(string name)
{
return typeof(T).GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
private static Dictionary<MethodInfo, HarmonyMethod> methodCache = new Dictionary<MethodInfo, HarmonyMethod>();
private static HarmonyMethod GetHarmonyMethod(MethodInfo method)
{
if (methodCache.TryGetValue(method, out HarmonyMethod harmonyMethod))
return harmonyMethod;
else
{
harmonyMethod = new HarmonyMethod(method);
methodCache.Add(method, harmonyMethod);
return harmonyMethod;
}
}
private static void PatchAllEnemies()
{
if (!ConfigManager.enemyTweakToggle.value)
return;
if (ConfigManager.friendlyFireDamageOverrideToggle.value)
{
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<PhysicalShockwave>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<VirtueInsignia>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<Flammable>("Burn"), prefix: GetHarmonyMethod(GetMethod<Flammable_Burn_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<FireZone>("OnTriggerStay"), prefix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("UpdateModifiers"), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_UpdateModifiers>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Start"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Start_Patch>("Postfix")));
if (ConfigManager.cerberusDashToggle.value)
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopDash"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopDash_Patch>("Postfix")));
if(ConfigManager.cerberusParryable.value)
{
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopTracking"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopTracking_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Stomp"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Stomp_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Statue>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Statue_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Drone_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("Shoot"), prefix: GetHarmonyMethod(GetMethod<Drone_Shoot_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("PlaySound"), prefix: GetHarmonyMethod(GetMethod<Drone_PlaySound_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Update"), postfix: GetHarmonyMethod(GetMethod<Drone_Update>("Postfix")));
if(ConfigManager.droneHomeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Drone_Death_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Drone_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Ferryman>("Start"), postfix: GetHarmonyMethod(GetMethod<FerrymanStart>("Postfix")));
if(ConfigManager.ferrymanComboToggle.value)
harmonyTweaks.Patch(GetMethod<Ferryman>("StopMoving"), postfix: GetHarmonyMethod(GetMethod<FerrymanStopMoving>("Postfix")));
if(ConfigManager.filthExplodeToggle.value)
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch2>("Prefix")));
if(ConfigManager.fleshPrisonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<FleshPrisonShoot>("Postfix")));
if (ConfigManager.hideousMassInsigniaToggle.value)
{
harmonyTweaks.Patch(GetMethod<Projectile>("Explode"), postfix: GetHarmonyMethod(GetMethod<Projectile_Explode_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mass>("ShootExplosive"), postfix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Postfix")), prefix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<SpiderBody>("Start"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("ChargeBeam"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ChargeBeam>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("BeamChargeEnd"), prefix: GetHarmonyMethod(GetMethod<MaliciousFace_BeamChargeEnd>("Prefix")));
if (ConfigManager.maliciousFaceHomingProjectileToggle.value)
{
harmonyTweaks.Patch(GetMethod<SpiderBody>("ShootProj"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ShootProj_Patch>("Postfix")));
}
if (ConfigManager.maliciousFaceRadianceOnEnrage.value)
harmonyTweaks.Patch(GetMethod<SpiderBody>("Enrage"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Enrage_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("Start"), postfix: GetHarmonyMethod(GetMethod<Mindflayer_Start_Patch>("Postfix")));
if (ConfigManager.mindflayerShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mindflayer>("ShootProjectiles"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_ShootProjectiles_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_MF>("Prefix")));
}
if (ConfigManager.mindflayerTeleportComboToggle.value)
{
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("MeleeTeleport"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_MeleeTeleport_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwingCheck2>("DamageStop"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_DamageStop_Patch>("Postfix")));
}
if (ConfigManager.minosPrimeRandomTeleportToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("Postfix")));
if (ConfigManager.minosPrimeTeleportTrail.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("Teleport"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("TeleportPostfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Start"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Dropkick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Dropkick>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Combo"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Combo>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("StopAction"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_StopAction>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Ascend"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Ascend>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Death"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Death>("Prefix")));
if (ConfigManager.minosPrimeCrushAttackToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("RiderKick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_RiderKick>("Prefix")));
if (ConfigManager.minosPrimeComboExplosiveEndToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_ProjectileCharge>("Prefix")));
if (ConfigManager.schismSpreadAttackToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ShootProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ShootProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<Solider_Start_Patch>("Postfix")));
}
if(ConfigManager.soliderCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_SpawnProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootGrenadeToggle.value || ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Stalker>("SandExplode"), prefix: GetHarmonyMethod(GetMethod<Stalker_SandExplode_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SandificationZone>("Enter"), postfix: GetHarmonyMethod(GetMethod<SandificationZone_Enter_Patch>("Postfix")));
if (ConfigManager.strayCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Swing>("Postfix")));
if (ConfigManager.strayShootToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_Start_Patch1>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("DamageEnd"), prefix: GetHarmonyMethod(GetMethod<DamageEnd>("Prefix")));
}
if(ConfigManager.streetCleanerCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<Streetcleaner>("Start"), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Start_Patch>("Postfix")));
if(ConfigManager.streetCleanerPredictiveDodgeToggle.value)
harmonyTweaks.Patch(GetMethod<BulletCheck>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<BulletCheck_OnTriggerEnter_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Start"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Start>("Postfix")));
if (ConfigManager.swordsMachineNoLightKnockbackToggle.value || ConfigManager.swordsMachineSecondPhaseMode.value != ConfigManager.SwordsMachineSecondPhase.None)
{
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Knockdown"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Knockdown_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Down"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwordsMachine>("SetSpeed"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_SetSpeed_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("EndFirstPhase"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Prefix")));
}
if (ConfigManager.swordsMachineExplosiveSwordToggle.value)
{
harmonyTweaks.Patch(GetMethod<ThrownSword>("Start"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ThrownSword>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_OnTriggerEnter_Patch>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Turret>("Start"), postfix: GetHarmonyMethod(GetMethod<TurretStart>("Postfix")));
if(ConfigManager.turretBurstFireToggle.value)
{
harmonyTweaks.Patch(GetMethod<Turret>("Shoot"), prefix: GetHarmonyMethod(GetMethod<TurretShoot>("Prefix")));
harmonyTweaks.Patch(GetMethod<Turret>("StartAiming"), postfix: GetHarmonyMethod(GetMethod<TurretAim>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Explosion>("Start"), postfix: GetHarmonyMethod(GetMethod<V2CommonExplosion>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2FirstStart>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2FirstUpdate>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2FirstShootWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2SecondStart>("Postfix")));
//if(ConfigManager.v2SecondStartEnraged.value)
// harmonyTweaks.Patch(GetMethod<BossHealthBar>("OnEnable"), postfix: GetHarmonyMethod(GetMethod<V2SecondEnrage>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2SecondUpdate>("Prefix")));
//harmonyTweaks.Patch(GetMethod<V2>("AltShootWeapon"), postfix: GetHarmonyMethod(GetMethod<V2AltShootWeapon>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("SwitchWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondSwitchWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Prefix")), postfix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Postfix")));
if(ConfigManager.v2SecondFastCoinToggle.value)
harmonyTweaks.Patch(GetMethod<V2>("ThrowCoins"), prefix: GetHarmonyMethod(GetMethod<V2SecondFastCoin>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<V2RocketLauncher>("CannonBallTriggerPrefix")));
if (ConfigManager.v2FirstSharpshooterToggle.value || ConfigManager.v2SecondSharpshooterToggle.value)
{
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("PrepareAltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverPrepareAltFire>("Prefix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverBullet>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("AltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverAltShoot>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Virtue_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Virtue_SpawnInsignia_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Virtue_Death_Patch>("Prefix")));
if (ConfigManager.sisyInstJumpShockwave.value)
{
harmonyTweaks.Patch(GetMethod<Sisyphus>("Start"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Sisyphus>("Update"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Update>("Postfix")));
}
if(ConfigManager.sisyInstBoulderShockwave.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("SetupExplosion"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_SetupExplosion>("Postfix")));
if(ConfigManager.sisyInstStrongerExplosion.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("StompExplosion"), prefix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_StompExplosion>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("Awake"), postfix: GetHarmonyMethod(GetMethod<LeviathanTail_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("BigSplash"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_BigSplash>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("Start"), postfix: GetHarmonyMethod(GetMethod<Leviathan_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurst"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurstStart"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurstStart>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<Leviathan_FixedUpdate>("Prefix")));
if (ConfigManager.somethingWickedSpear.value)
{
harmonyTweaks.Patch(GetMethod<Wicked>("Start"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_GetHit>("Postfix")));
}
if(ConfigManager.somethingWickedSpawnOn43.value)
{
harmonyTweaks.Patch(GetMethod<ObjectActivator>("Activate"), prefix: GetHarmonyMethod(GetMethod<ObjectActivator_Activate>("Prefix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<JokeWicked_GetHit>("Postfix")));
}
if (ConfigManager.panopticonFullPhase.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Panopticon_Start>("Postfix")));
if (ConfigManager.panopticonAxisBeam.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnInsignia>("Prefix")));
if (ConfigManager.panopticonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<Panopticon_HomingProjectileAttack>("Postfix")));
if (ConfigManager.panopticonBlackholeProj.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnBlackHole"), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnBlackHole>("Postfix")));
if (ConfigManager.panopticonBalanceEyes.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnFleshDrones"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Postfix")));
if (ConfigManager.panopticonBlueProjToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Update"), transpiler: GetHarmonyMethod(GetMethod<Panopticon_BlueProjectile>("Transpiler")));
if (ConfigManager.idolExplosionToggle.value)
harmonyTweaks.Patch(GetMethod<Idol>("Death"), postfix: GetHarmonyMethod(GetMethod<Idol_Death_Patch>("Postfix")));
// ADDME
/*
harmonyTweaks.Patch(GetMethod<GabrielSecond>("Start"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("BasicCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_BasicCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("FastCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_FastCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("CombineSwords"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_CombineSwords>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("ThrowCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_ThrowCombo>("Postfix")));
*/
}
private static void PatchAllPlayers()
{
if (!ConfigManager.playerTweakToggle.value)
return;
harmonyTweaks.Patch(GetMethod<Punch>("CheckForProjectile"), prefix: GetHarmonyMethod(GetMethod<Punch_CheckForProjectile_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch1>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Collision"), prefix: GetHarmonyMethod(GetMethod<Grenade_Collision_Patch>("Prefix")));
if (ConfigManager.rocketBoostToggle.value)
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_Patch>("Prefix")));
if (ConfigManager.rocketGrabbingToggle.value)
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate_Patch>("Prefix")));
if (ConfigManager.orbStrikeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Coin>("Start"), postfix: GetHarmonyMethod(GetMethod<Coin_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Punch>("BlastCheck"), prefix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Postfix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide>("Prefix")));
harmonyTweaks.Patch(GetMethod<Coin>("DelayedReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_DelayedReflectRevolver>("Postfix")));
harmonyTweaks.Patch(GetMethod<Coin>("ReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Prefix")), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Postfix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("ExecuteHits"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("HitSomething"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("Start"), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_Start>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("Explode"), prefix: GetHarmonyMethod(GetMethod<Cannonball_Explode>("Prefix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_CollideOrbital>("Prefix")));
}
if(ConfigManager.chargedRevRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Revolver>("Update"), prefix: GetHarmonyMethod(GetMethod<Revolver_Update>("Prefix")));
if(ConfigManager.coinRegSpeedMulti.value != 1 || ConfigManager.sharpshooterRegSpeedMulti.value != 1
|| ConfigManager.railcannonRegSpeedMulti.value != 1 || ConfigManager.rocketFreezeRegSpeedMulti.value != 1
|| ConfigManager.rocketCannonballRegSpeedMulti.value != 1 || ConfigManager.nailgunAmmoRegSpeedMulti.value != 1
|| ConfigManager.sawAmmoRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<WeaponCharges>("Charge"), prefix: GetHarmonyMethod(GetMethod<WeaponCharges_Charge>("Prefix")));
if(ConfigManager.nailgunHeatsinkRegSpeedMulti.value != 1 || ConfigManager.sawHeatsinkRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Nailgun>("Update"), prefix: GetHarmonyMethod(GetMethod<NailGun_Update>("Prefix")));
if(ConfigManager.staminaRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("Update"), prefix: GetHarmonyMethod(GetMethod<NewMovement_Update>("Prefix")));
if(ConfigManager.playerHpDeltaToggle.value || ConfigManager.maxPlayerHp.value != 100 || ConfigManager.playerHpSupercharge.value != 200 || ConfigManager.whiplashHardDamageCap.value != 50 || ConfigManager.whiplashHardDamageSpeed.value != 1)
{
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHealth"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHealth>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("SuperCharge"), prefix: GetHarmonyMethod(GetMethod<NewMovement_SuperCharge>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Respawn"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Respawn>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Start"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Transpiler")));
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), transpiler: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate>("Transpiler")));
harmonyTweaks.Patch(GetMethod<NewMovement>("ForceAntiHP"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_ForceAntiHP>("Transpiler")));
}
// ADDME
harmonyTweaks.Patch(GetMethod<Revolver>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Revolver_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Shotgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Transpiler")), prefix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Postfix")));
harmonyTweaks.Patch(GetMethod<Shotgun>("ShootSinks"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_ShootSinks>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("SuperSaw"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_SuperSaw>("Transpiler")));
if (ConfigManager.hardDamagePercent.normalizedValue != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Prefix")), postfix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Start"), postfix: GetHarmonyMethod(GetMethod<HealthBar_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Update"), transpiler: GetHarmonyMethod(GetMethod<HealthBar_Update>("Transpiler")));
foreach (HealthBarTracker hb in HealthBarTracker.instances)
{
if (hb != null)
hb.SetSliderRange();
}
harmonyTweaks.Patch(GetMethod<Harpoon>("Start"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Start>("Postfix")));
if(ConfigManager.screwDriverHomeToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("Punched"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Punched>("Postfix")));
if(ConfigManager.screwDriverSplitToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<Harpoon_OnTriggerEnter_Patch>("Prefix")));
}
private static void PatchAllMemes()
{
if (ConfigManager.enrageSfxToggle.value)
harmonyTweaks.Patch(GetMethod<EnrageEffect>("Start"), postfix: GetHarmonyMethod(GetMethod<EnrageEffect_Start>("Postfix")));
if(ConfigManager.funnyDruidKnightSFXToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mandalore>("FullBurst"), postfix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Postfix")), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mandalore>("FullerBurst"), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullerBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Explode"), prefix: GetHarmonyMethod(GetMethod<Drone_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Drone_Explode>("Postfix")));
}
if (ConfigManager.fleshObamiumToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Prefix")));
if (ConfigManager.obamapticonToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Prefix")));
}
public static bool methodsPatched = false;
public static void ScenePatchCheck()
{
if(methodsPatched && !ultrapainDifficulty)
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
}
else if(!methodsPatched && ultrapainDifficulty)
{
PatchAll();
}
}
public static void PatchAll()
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
if (!ultrapainDifficulty)
return;
if(realUltrapainDifficulty && ConfigManager.discordRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<DiscordController>("SendActivity"), prefix: GetHarmonyMethod(GetMethod<DiscordController_SendActivity_Patch>("Prefix")));
if (realUltrapainDifficulty && ConfigManager.steamRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<SteamFriends>("SetRichPresence"), prefix: GetHarmonyMethod(GetMethod<SteamFriends_SetRichPresence_Patch>("Prefix")));
PatchAllEnemies();
PatchAllPlayers();
PatchAllMemes();
methodsPatched = true;
}
public static string workingPath;
public static string workingDir;
public static AssetBundle bundle;
public static AudioClip druidKnightFullAutoAud;
public static AudioClip druidKnightFullerAutoAud;
public static AudioClip druidKnightDeathAud;
public static AudioClip enrageAudioCustom;
public static GameObject fleshObamium;
public static GameObject obamapticon;
public void Awake()
{
instance = this;
workingPath = Assembly.GetExecutingAssembly().Location;
workingDir = Path.GetDirectoryName(workingPath);
Logger.LogInfo($"Working path: {workingPath}, Working dir: {workingDir}");
try
{
bundle = AssetBundle.LoadFromFile(Path.Combine(workingDir, "ultrapain"));
druidKnightFullAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullauto.wav");
druidKnightFullerAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullerauto.wav");
druidKnightDeathAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/death.wav");
enrageAudioCustom = bundle.LoadAsset<AudioClip>("assets/ultrapain/sfx/enraged.wav");
fleshObamium = bundle.LoadAsset<GameObject>("assets/ultrapain/fleshprison/fleshobamium.prefab");
obamapticon = bundle.LoadAsset<GameObject>("assets/ultrapain/panopticon/obamapticon.prefab");
}
catch (Exception e)
{
Logger.LogError($"Could not load the asset bundle:\n{e}");
}
// DEBUG
/*string logPath = Path.Combine(Environment.CurrentDirectory, "log.txt");
Logger.LogInfo($"Saving to {logPath}");
List<string> assetPaths = new List<string>()
{
"fonts.bundle",
"videos.bundle",
"shaders.bundle",
"particles.bundle",
"materials.bundle",
"animations.bundle",
"prefabs.bundle",
"physicsmaterials.bundle",
"models.bundle",
"textures.bundle",
};
//using (FileStream log = File.Open(logPath, FileMode.OpenOrCreate, FileAccess.Write))
//{
foreach(string assetPath in assetPaths)
{
Logger.LogInfo($"Attempting to load {assetPath}");
AssetBundle bundle = AssetBundle.LoadFromFile(Path.Combine(bundlePath, assetPath));
bundles.Add(bundle);
//foreach (string name in bundle.GetAllAssetNames())
//{
// string line = $"[{bundle.name}][{name}]\n";
// log.Write(Encoding.ASCII.GetBytes(line), 0, line.Length);
//}
bundle.LoadAllAssets();
}
//}
*/
// Plugin startup logic
Logger.LogInfo($"Plugin {PluginInfo.PLUGIN_GUID} is loaded!");
harmonyTweaks = new Harmony(PLUGIN_GUID + "_tweaks");
harmonyBase = new Harmony(PLUGIN_GUID + "_base");
harmonyBase.Patch(GetMethod<DifficultySelectButton>("SetDifficulty"), postfix: GetHarmonyMethod(GetMethod<DifficultySelectPatch>("Postfix")));
harmonyBase.Patch(GetMethod<DifficultyTitle>("Check"), postfix: GetHarmonyMethod(GetMethod<DifficultyTitle_Check_Patch>("Postfix")));
harmonyBase.Patch(typeof(PrefsManager).GetConstructor(new Type[0]), postfix: GetHarmonyMethod(GetMethod<PrefsManager_Ctor>("Postfix")));
harmonyBase.Patch(GetMethod<PrefsManager>("EnsureValid"), prefix: GetHarmonyMethod(GetMethod<PrefsManager_EnsureValid>("Prefix")));
harmonyBase.Patch(GetMethod<Grenade>("Explode"), prefix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Prefix")), postfix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Postfix")));
LoadPrefabs();
ConfigManager.Initialize();
SceneManager.activeSceneChanged += OnSceneChange;
}
}
public static class Tools
{
private static Transform _target;
private static Transform target { get
{
if(_target == null)
_target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
return _target;
}
}
public static Vector3 PredictPlayerPosition(float speedMod, Collider enemyCol = null)
{
Vector3 projectedPlayerPos;
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
{
return target.position;
}
RaycastHit raycastHit;
if (enemyCol != null && Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == enemyCol)
{
projectedPlayerPos = target.position;
}
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
projectedPlayerPos = raycastHit.point;
}
else
{
projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
projectedPlayerPos = new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
return projectedPlayerPos;
}
}
// Asset destroyer tracker
/*[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass1
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object), typeof(float) })]
public class TempClass2
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass3
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object), typeof(bool) })]
public class TempClass4
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}*/
}
| Ultrapain/Plugin.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel streetCleanerPanel;\n public static ConfigPanel swordsMachinePanel;\n public static ConfigPanel virtuePanel;\n public static ConfigPanel ferrymanPanel;\n public static ConfigPanel turretPanel;\n public static ConfigPanel fleshPrisonPanel;\n public static ConfigPanel minosPrimePanel;\n public static ConfigPanel v2FirstPanel;\n public static ConfigPanel v2SecondPanel;\n public static ConfigPanel sisyInstPanel;",
"score": 0.8651120066642761
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel leviathanPanel;\n public static ConfigPanel somethingWickedPanel;\n public static ConfigPanel panopticonPanel;\n public static ConfigPanel idolPanel;\n // GLOBAL ENEMY CONFIG\n public static BoolField friendlyFireDamageOverrideToggle;\n public static FloatSliderField friendlyFireDamageOverrideExplosion;\n public static FloatSliderField friendlyFireDamageOverrideProjectile;\n public static FloatSliderField friendlyFireDamageOverrideFire;\n public static FloatSliderField friendlyFireDamageOverrideMelee;",
"score": 0.8524923324584961
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel cerberusPanel;\n public static ConfigPanel dronePanel;\n public static ConfigPanel filthPanel;\n public static ConfigPanel hideousMassPanel;\n public static ConfigPanel maliciousFacePanel;\n public static ConfigPanel mindflayerPanel;\n public static ConfigPanel schismPanel;\n public static ConfigPanel soliderPanel;\n public static ConfigPanel stalkerPanel;\n public static ConfigPanel strayPanel;",
"score": 0.8523582220077515
},
{
"filename": "Ultrapain/Patches/Virtue.cs",
"retrieved_chunk": " }\n }\n class VirtueFlag : MonoBehaviour\n {\n public AudioSource lighningBoltSFX;\n public GameObject ligtningBoltAud;\n public Transform windupObj;\n private EnemyIdentifier eid;\n public Drone virtue;\n public void Awake()",
"score": 0.8482746481895447
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " {\n private LeviathanHead comp;\n private Animator anim;\n //private Collider col;\n private LayerMask envMask = new LayerMask() { value = 1 << 8 | 1 << 24 };\n public float playerRocketRideTracker = 0;\n private GameObject currentProjectileEffect;\n private AudioSource currentProjectileAud;\n private Transform shootPoint;\n public float currentProjectileSize = 0;",
"score": 0.8391175866127014
}
] | csharp | AudioClip cannonBallChargeAudio; |
// -------------------------------------------------------------
// Copyright (c) - The Standard Community - All rights reserved.
// -------------------------------------------------------------
using System;
using System.IO;
using System.Linq;
using Newtonsoft.Json;
using Standard.REST.RESTFulSense.Models.Foundations.StatusDetails;
using Standard.REST.RESTFulSense.Models.Foundations.StatusDetails.Exceptions;
using Xeptions;
namespace Standard.REST.RESTFulSense.Services.Foundations.StatusDetails
{
internal partial class StatusDetailService
{
private delegate IQueryable<StatusDetail> ReturningStatusDetailsFunction();
private delegate StatusDetail ReturningStatusDetailFunction();
private IQueryable<StatusDetail> TryCatch(ReturningStatusDetailsFunction returningStatusDetailsFunction)
{
try
{
return returningStatusDetailsFunction();
}
catch (JsonReaderException jsonReaderException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonReaderException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (JsonSerializationException jsonSerializationException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonSerializationException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (JsonException jsonException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (ArgumentNullException argumentNullException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(argumentNullException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (ArgumentException argumentException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(argumentException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (PathTooLongException pathTooLongException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(pathTooLongException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (DirectoryNotFoundException directoryNotFoundException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(directoryNotFoundException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (FileNotFoundException fileNotFoundException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(fileNotFoundException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (UnauthorizedAccessException unauthorizedAccessException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(unauthorizedAccessException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (NotSupportedException notSupportedException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(notSupportedException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (IOException iOException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(iOException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (Exception exception)
{
var failedStatusDetailServiceException =
new FailedStatusDetailServiceException(exception);
throw CreateAndLogServiceException(failedStatusDetailServiceException);
}
}
private StatusDetail TryCatch(ReturningStatusDetailFunction returningStatusDetailFunction)
{
try
{
return returningStatusDetailFunction();
}
catch (NotFoundStatusDetailException notFoundStatusDetailException)
{
throw CreateAndLogValidationException(notFoundStatusDetailException);
}
catch (JsonReaderException jsonReaderException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonReaderException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (JsonSerializationException jsonSerializationException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonSerializationException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (JsonException jsonException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(jsonException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (ArgumentNullException argumentNullException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(argumentNullException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (ArgumentException argumentException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(argumentException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (PathTooLongException pathTooLongException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(pathTooLongException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (DirectoryNotFoundException directoryNotFoundException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(directoryNotFoundException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (FileNotFoundException fileNotFoundException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(fileNotFoundException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (UnauthorizedAccessException unauthorizedAccessException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(unauthorizedAccessException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (NotSupportedException notSupportedException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(notSupportedException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (IOException iOException)
{
var failedStatusDetailStorageException =
new FailedStatusDetailStorageException(iOException);
throw CreateAndLogDependencyException(failedStatusDetailStorageException);
}
catch (Exception exception)
{
var failedStatusDetailServiceException =
new FailedStatusDetailServiceException(exception);
throw CreateAndLogServiceException(failedStatusDetailServiceException);
}
}
private | StatusDetailDependencyException CreateAndLogDependencyException(Xeption exception)
{ |
var statusDetailDependencyException =
new StatusDetailDependencyException(exception);
return statusDetailDependencyException;
}
private StatusDetailValidationException CreateAndLogValidationException(Xeption exception)
{
var statusDetailValidationException =
new StatusDetailValidationException(exception);
return statusDetailValidationException;
}
private StatusDetailServiceException CreateAndLogServiceException(Xeption exception)
{
var statusDetailServiceException =
new StatusDetailServiceException(exception);
return statusDetailServiceException;
}
}
}
| Standard.REST.RESTFulSense/Services/Foundations/StatusDetails/StatusDetailService.Exceptions.cs | The-Standard-Organization-Standard.REST.RESTFulSense-7598bbe | [
{
"filename": "Standard.REST.RESTFulSense.Tests.Unit/Services/Foundations/StatusDetails/StatusDetailServiceTests.Exceptions.RetrieveStatusDetailByStatusCode.cs",
"retrieved_chunk": " public void ShouldThrowServiceExceptionOnRetrieveStatusDetailByCodeIfServiceErrorOccurs()\n {\n // given\n int someCode = GetRandomNumber();\n string exceptionMessage = GetRandomString();\n var serviceException = new Exception(exceptionMessage);\n var failedStatusDetailServiceException =\n new FailedStatusDetailServiceException(serviceException);\n var expectedStatusDetailServiceException =\n new StatusDetailServiceException(failedStatusDetailServiceException);",
"score": 0.8744277358055115
},
{
"filename": "Standard.REST.RESTFulSense.Tests.Unit/Services/Foundations/StatusDetails/StatusDetailServiceTests.Exceptions.RetrieveAll.cs",
"retrieved_chunk": " public partial class StatusDetailServiceTests\n {\n [Theory]\n [MemberData(nameof(DependencyExceptions))]\n public void ShouldThrowDependencyExceptionOnRetrieveAllWhenExceptionOccurs(\n Exception dependancyException)\n {\n // given\n var failedStorageException =\n new FailedStatusDetailStorageException(dependancyException);",
"score": 0.8643665909767151
},
{
"filename": "Standard.REST.RESTFulSense.Tests.Unit/Services/Foundations/StatusDetails/StatusDetailServiceTests.Exceptions.RetrieveAll.cs",
"retrieved_chunk": " {\n // given\n string exceptionMessage = GetRandomString();\n var serviceException = new Exception(exceptionMessage);\n var failedStatusDetailServiceException =\n new FailedStatusDetailServiceException(serviceException);\n var expectedStatusDetailServiceException =\n new StatusDetailServiceException(failedStatusDetailServiceException);\n this.storageBrokerMock.Setup(broker =>\n broker.SelectAllStatusDetails())",
"score": 0.8641246557235718
},
{
"filename": "Standard.REST.RESTFulSense.Tests.Unit/Services/Foundations/StatusDetails/StatusDetailServiceTests.Exceptions.RetrieveStatusDetailByStatusCode.cs",
"retrieved_chunk": " public partial class StatusDetailServiceTests\n {\n [Theory]\n [MemberData(nameof(DependencyExceptions))]\n public void ShouldThrowDependencyExceptionOnRetrieveStatusDetailByCodeIfErrorOccurs(\n Exception dependancyException)\n {\n // given\n int someCode = GetRandomNumber();\n var failedStorageException =",
"score": 0.8276464939117432
},
{
"filename": "Standard.REST.RESTFulSense.Tests.Unit/Services/Foundations/StatusDetails/StatusDetailServiceTests.Exceptions.RetrieveStatusDetailByStatusCode.cs",
"retrieved_chunk": " new FailedStatusDetailStorageException(dependancyException);\n var expectedStatusDetailDependencyException =\n new StatusDetailDependencyException(failedStorageException);\n this.storageBrokerMock.Setup(broker =>\n broker.SelectAllStatusDetails())\n .Throws(dependancyException);\n // when\n Action retrieveStatusDetailByCodeAction = () =>\n this.statusDetailService.RetrieveStatusDetailByCode(someCode);\n StatusDetailDependencyException actualStatusDetailDependencyException =",
"score": 0.8223521709442139
}
] | csharp | StatusDetailDependencyException CreateAndLogDependencyException(Xeption exception)
{ |
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Concurrent;
namespace Ryan.EntityFrameworkCore.Proxy
{
/// <summary>
/// 上下文实体代理字典
/// </summary>
public class DbContextEntityProxyLookup : ConcurrentDictionary<Type, DbContextEntityProxy>
{
private readonly | IDbContextEntityProxyGenerator _dbContextEntityProxyGenerator; |
public DbContextEntityProxyLookup(IDbContextEntityProxyGenerator dbContextEntityProxyGenerator)
{
_dbContextEntityProxyGenerator = dbContextEntityProxyGenerator;
}
public DbContextEntityProxy GetOrDefault(Type entityType, DbContext context)
{
return GetOrAdd(entityType, _dbContextEntityProxyGenerator.Create(context));
}
public void Changes()
{
foreach (var context in Values)
{
for (int i = context.EntityProxies.Count - 1; i >= 0; i--)
{
if (!context.EntityProxies[i].IsStated())
{
context.EntityProxies.RemoveAt(i);
continue;
}
context.EntityProxies[i].Changes();
}
}
}
public void Changed()
{
foreach (var context in Values)
{
for (int i = context.EntityProxies.Count - 1; i >= 0; i--)
{
context.EntityProxies[i].Changed();
}
}
}
}
}
| src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/DbContextEntityProxyLookup.cs | c-y-r-Ryan.EntityFrameworkCore.Shard-f15124c | [
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/DbContextEntityProxyLookupGenerator.cs",
"retrieved_chunk": "using Microsoft.EntityFrameworkCore;\nusing Microsoft.Extensions.Caching.Memory;\nusing Ryan.EntityFrameworkCore.Infrastructure;\nnamespace Ryan.EntityFrameworkCore.Proxy\n{\n /// <inheritdoc cref=\"IDbContextEntityProxyLookupGenerator\"/>\n public class DbContextEntityProxyLookupGenerator : IDbContextEntityProxyLookupGenerator\n {\n /// <summary>\n /// 上下文实体代理生成器",
"score": 0.9073294401168823
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/IDbContextEntityProxyLookupGenerator.cs",
"retrieved_chunk": "using Microsoft.EntityFrameworkCore;\nnamespace Ryan.EntityFrameworkCore.Proxy\n{\n /// <summary>\n /// 上下文实体代理字典生成器\n /// </summary>\n public interface IDbContextEntityProxyLookupGenerator\n {\n /// <summary>\n /// 创建上下文实体代理字典",
"score": 0.9019196033477783
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/DbContextEntityProxy.cs",
"retrieved_chunk": "using Microsoft.EntityFrameworkCore;\nusing System.Collections.Generic;\nnamespace Ryan.EntityFrameworkCore.Proxy\n{\n /// <summary>\n /// 上下文实体代理\n /// </summary>\n public class DbContextEntityProxy\n {\n /// <summary>",
"score": 0.8911933898925781
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/IDbContextEntityProxyGenerator.cs",
"retrieved_chunk": "using Microsoft.EntityFrameworkCore;\nnamespace Ryan.EntityFrameworkCore.Proxy\n{\n /// <summary>\n /// 数据上下文实体代理生成器\n /// </summary>\n public interface IDbContextEntityProxyGenerator\n {\n /// <summary>\n /// 创建上下文实体代理",
"score": 0.8896567225456238
},
{
"filename": "src/Ryan.EntityFrameworkCore.Shard/EntityFrameworkCore/Proxy/IEntityProxyGenerator.cs",
"retrieved_chunk": "using Microsoft.EntityFrameworkCore;\nnamespace Ryan.EntityFrameworkCore.Proxy\n{\n /// <summary>\n /// 实体代理生成器\n /// </summary>\n public interface IEntityProxyGenerator\n {\n /// <summary>\n /// 生成实体代理",
"score": 0.8677555918693542
}
] | csharp | IDbContextEntityProxyGenerator _dbContextEntityProxyGenerator; |
using HarmonyLib;
using Mono.Cecil;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using UnityEngine;
namespace Ultrapain.Patches
{
/*
u = initial, f = final, d = delta, s = speed multiplier
u = 40f * Time.deltaTime
f = 40f * S * Time.deltaTime
d = 40f * Time.deltaTime * (S - 1)
revCharge += 40f * Time.deltaTime * (S - 1f) * (alt ? 0.5f : 1f)
*/
class Revolver_Update
{
static bool Prefix(Revolver __instance)
{
if(__instance.gunVariation == 0 && __instance.pierceCharge < 100f)
{
__instance.pierceCharge = Mathf.Min(100f, __instance.pierceCharge + 40f * Time.deltaTime * (ConfigManager.chargedRevRegSpeedMulti.value - 1f) * (__instance.altVersion ? 0.5f : 1f));
}
return true;
}
}
public class Revolver_Shoot
{
public static void RevolverBeamEdit(RevolverBeam beam)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.revolverAltDamage.value : ConfigManager.revolverDamage.value;
}
public static void RevolverBeamSuperEdit(RevolverBeam beam)
{
if (beam.gunVariation == 0)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.chargedAltRevDamage.value : ConfigManager.chargedRevDamage.value;
beam.hitAmount = beam.strongAlt ? ConfigManager.chargedAltRevTotalHits.value : ConfigManager.chargedRevTotalHits.value;
beam.maxHitsPerTarget = beam.strongAlt ? ConfigManager.chargedAltRevMaxHitsPerTarget.value : ConfigManager.chargedRevMaxHitsPerTarget.value;
}
else if (beam.gunVariation == 2)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.sharpshooterAltDamage.value : ConfigManager.sharpshooterDamage.value;
beam.maxHitsPerTarget = beam.strongAlt ? ConfigManager.sharpshooterAltMaxHitsPerTarget.value : ConfigManager.sharpshooterMaxHitsPerTarget.value;
}
}
static FieldInfo f_RevolverBeam_gunVariation = typeof(RevolverBeam).GetField("gunVariation", UnityUtils.instanceFlag);
static MethodInfo m_Revolver_Shoot_RevolverBeamEdit = typeof(Revolver_Shoot).GetMethod("RevolverBeamEdit", UnityUtils.staticFlag);
static MethodInfo m_Revolver_Shoot_RevolverBeamSuperEdit = typeof(Revolver_Shoot).GetMethod("RevolverBeamSuperEdit", UnityUtils.staticFlag);
static MethodInfo m_GameObject_GetComponent_RevolverBeam = typeof(GameObject).GetMethod("GetComponent", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(RevolverBeam) });
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
object normalBeamLocalIndex = null;
object superBeamLocalIndex = null;
// Get local indexes of components for RevolverBeam references
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_GameObject_GetComponent_RevolverBeam))
{
object localIndex = ILUtils.GetLocalIndex(code[i + 1]);
if (localIndex == null)
continue;
if (normalBeamLocalIndex == null)
{
normalBeamLocalIndex = localIndex;
}
else
{
superBeamLocalIndex = localIndex;
break;
}
}
}
Debug.Log($"Normal beam index: {normalBeamLocalIndex}");
Debug.Log($"Super beam index: {superBeamLocalIndex}");
// Modify normal beam
for (int i = 3; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_RevolverBeam_gunVariation))
{
object localIndex = ILUtils.GetLocalIndex(code[i - 3]);
if (localIndex == null)
continue;
if (localIndex.Equals(normalBeamLocalIndex))
{
Debug.Log($"Patching normal beam");
i += 1;
code.Insert(i, ILUtils.LoadLocalInstruction(localIndex));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Revolver_Shoot_RevolverBeamEdit));
break;
}
}
}
// Modify super beam
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_RevolverBeam_gunVariation))
{
object localIndex = ILUtils.GetLocalIndex(code[i - 3]);
if (localIndex == null)
continue;
if (localIndex.Equals(superBeamLocalIndex))
{
Debug.Log($"Patching super beam");
i += 1;
code.Insert(i, ILUtils.LoadLocalInstruction(localIndex));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Revolver_Shoot_RevolverBeamSuperEdit));
break;
}
}
}
return code.AsEnumerable();
}
}
public class Shotgun_Shoot
{
public static void ModifyShotgunPellet(Projectile proj, Shotgun shotgun, int primaryCharge)
{
if (shotgun.variation == 0)
{
proj.damage = ConfigManager.shotgunBlueDamagePerPellet.value;
}
else
{
if (primaryCharge == 0)
proj.damage = ConfigManager.shotgunGreenPump1Damage.value;
else if (primaryCharge == 1)
proj.damage = ConfigManager.shotgunGreenPump2Damage.value;
else if (primaryCharge == 2)
proj.damage = ConfigManager.shotgunGreenPump3Damage.value;
}
}
public static void ModifyPumpExplosion(Explosion exp)
{
exp.damage = ConfigManager.shotgunGreenExplosionDamage.value;
exp.playerDamageOverride = ConfigManager.shotgunGreenExplosionPlayerDamage.value;
float sizeMulti = ConfigManager.shotgunGreenExplosionSize.value / 9f;
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.speed *= ConfigManager.shotgunGreenExplosionSpeed.value;
}
static MethodInfo m_GameObject_GetComponent_Projectile = typeof(GameObject).GetMethod("GetComponent", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(Projectile) });
static MethodInfo m_GameObject_GetComponentsInChildren_Explosion = typeof(GameObject).GetMethod("GetComponentsInChildren", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(Explosion) });
static MethodInfo m_Shotgun_Shoot_ModifyShotgunPellet = typeof(Shotgun_Shoot).GetMethod("ModifyShotgunPellet", UnityUtils.staticFlag);
static MethodInfo m_Shotgun_Shoot_ModifyPumpExplosion = typeof(Shotgun_Shoot).GetMethod("ModifyPumpExplosion", UnityUtils.staticFlag);
static FieldInfo f_Shotgun_primaryCharge = typeof(Shotgun).GetField("primaryCharge", UnityUtils.instanceFlag);
static FieldInfo f_Explosion_damage = typeof(Explosion).GetField("damage", UnityUtils.instanceFlag);
static bool Prefix(Shotgun __instance, int ___primaryCharge)
{
if (__instance.variation == 0)
{
__instance.spread = ConfigManager.shotgunBlueSpreadAngle.value;
}
else
{
if (___primaryCharge == 0)
__instance.spread = ConfigManager.shotgunGreenPump1Spread.value * 1.5f;
else if (___primaryCharge == 1)
__instance.spread = ConfigManager.shotgunGreenPump2Spread.value;
else if (___primaryCharge == 2)
__instance.spread = ConfigManager.shotgunGreenPump3Spread.value / 2f;
}
return true;
}
static void Postfix(Shotgun __instance)
{
__instance.spread = 10f;
}
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction pelletStoreInst = new CodeInstruction(OpCodes.Stloc_0);
int pelletCodeIndex = 0;
// Find pellet local variable index
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldc_I4_S && code[i].OperandIs(12))
{
if (ConfigManager.shotgunBluePelletCount.value > sbyte.MaxValue)
code[i].opcode = OpCodes.Ldc_I4;
code[i].operand = ConfigManager.shotgunBluePelletCount.value;
i += 1;
pelletCodeIndex = i;
pelletStoreInst = code[i];
break;
}
}
// Debug.Log($"Pellet store instruction: {ILUtils.TurnInstToString(pelletStoreInst)}");
// Modify pellet counts
for (int i = pelletCodeIndex + 1; i < code.Count; i++)
{
if (code[i].opcode == pelletStoreInst.opcode
&& (pelletStoreInst.operand == null ? true : pelletStoreInst.operand.Equals(code[i].operand))
&& ILUtils.IsConstI4LoadWithOperand(code[i - 1].opcode))
{
int constIndex = i - 1;
int pelletCount = ILUtils.GetI4LoadOperand(code[constIndex]);
if (pelletCount == 10)
pelletCount = ConfigManager.shotgunGreenPump1Count.value;
else if (pelletCount == 16)
pelletCount = ConfigManager.shotgunGreenPump2Count.value;
else if (pelletCount == 24)
pelletCount = ConfigManager.shotgunGreenPump3Count.value;
if (ILUtils.TryEfficientLoadI4(pelletCount, out OpCode efficientOpcode))
{
code[constIndex].operand = null;
code[constIndex].opcode = efficientOpcode;
}
else
{
if (pelletCount > sbyte.MaxValue)
code[constIndex].opcode = OpCodes.Ldc_I4;
else
code[constIndex].opcode = OpCodes.Ldc_I4_S;
code[constIndex].operand = pelletCount;
}
}
}
// Modify projectile damage
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_GameObject_GetComponent_Projectile))
{
i += 1;
// Duplicate component (arg 0)
code.Insert(i, new CodeInstruction(OpCodes.Dup));
i += 1;
// Add instance to stack (arg 1)
code.Insert(i, new CodeInstruction(OpCodes.Ldarg_0));
i += 1;
// Load instance then get primary field (arg 2)
code.Insert(i, new CodeInstruction(OpCodes.Ldarg_0));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Ldfld, f_Shotgun_primaryCharge));
i += 1;
// Call the static method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_Shoot_ModifyShotgunPellet));
break;
}
}
// Modify pump explosion
int pumpExplosionIndex = 0;
while (code[pumpExplosionIndex].opcode != OpCodes.Callvirt && !code[pumpExplosionIndex].OperandIs(m_GameObject_GetComponentsInChildren_Explosion))
pumpExplosionIndex += 1;
for (int i = pumpExplosionIndex; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld)
{
if (code[i].OperandIs(f_Explosion_damage))
{
// Duplicate before damage assignment
code.Insert(i - 1, new CodeInstruction(OpCodes.Dup));
i += 2;
// Argument 0 already loaded, call the method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_Shoot_ModifyPumpExplosion));
// Stack is now clear
break;
}
}
}
return code.AsEnumerable();
}
}
// Core eject
class Shotgun_ShootSinks
{
public static void ModifyCoreEject(GameObject core)
{
GrenadeExplosionOverride ovr = core.AddComponent<GrenadeExplosionOverride>();
ovr.normalMod = true;
ovr.normalDamage = (float)ConfigManager.shotgunCoreExplosionDamage.value / 35f;
ovr.normalSize = (float)ConfigManager.shotgunCoreExplosionSize.value / 6f * ConfigManager.shotgunCoreExplosionSpeed.value;
ovr.normalPlayerDamageOverride = ConfigManager.shotgunCoreExplosionPlayerDamage.value;
ovr.superMod = true;
ovr.superDamage = (float)ConfigManager.shotgunCoreExplosionDamage.value / 35f;
ovr.superSize = (float)ConfigManager.shotgunCoreExplosionSize.value / 6f * ConfigManager.shotgunCoreExplosionSpeed.value;
ovr.superPlayerDamageOverride = ConfigManager.shotgunCoreExplosionPlayerDamage.value;
}
static FieldInfo f_Grenade_sourceWeapon = typeof(Grenade).GetField("sourceWeapon", UnityUtils.instanceFlag);
static MethodInfo m_Shotgun_ShootSinks_ModifyCoreEject = typeof(Shotgun_ShootSinks).GetMethod("ModifyCoreEject", UnityUtils.staticFlag);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_Grenade_sourceWeapon))
{
i += 1;
// Add arg 0
code.Insert(i, new CodeInstruction(OpCodes.Dup));
i += 1;
// Call mod method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_ShootSinks_ModifyCoreEject));
break;
}
}
return code.AsEnumerable();
}
}
class Nailgun_Shoot
{
static FieldInfo f_Nailgun_heatSinks = typeof(Nailgun).GetField("heatSinks", UnityUtils.instanceFlag);
static FieldInfo f_Nailgun_heatUp = typeof(Nailgun).GetField("heatUp", UnityUtils.instanceFlag);
public static void ModifyNail(Nailgun inst, GameObject nail)
{
Nail comp = nail.GetComponent<Nail>();
if (inst.altVersion)
{
// Blue saw launcher
if (inst.variation == 1)
{
comp.damage = ConfigManager.sawBlueDamage.value;
comp.hitAmount = ConfigManager.sawBlueHitAmount.value;
}
// Green saw launcher
else
{
comp.damage = ConfigManager.sawGreenDamage.value;
float maxHit = ConfigManager.sawGreenHitAmount.value;
float heatSinks = (float)f_Nailgun_heatSinks.GetValue(inst);
float heatUp = (float)f_Nailgun_heatUp.GetValue(inst);
if (heatSinks >= 1)
comp.hitAmount = Mathf.Lerp(maxHit, Mathf.Max(1f, maxHit), (maxHit - 2f) * heatUp);
else
comp.hitAmount = 1f;
}
}
else
{
// Blue nailgun
if (inst.variation == 1)
{
comp.damage = ConfigManager.nailgunBlueDamage.value;
}
else
{
if (comp.heated)
comp.damage = ConfigManager.nailgunGreenBurningDamage.value;
else
comp.damage = ConfigManager.nailgunGreenDamage.value;
}
}
}
static FieldInfo f_Nailgun_nail = typeof(Nailgun).GetField("nail", UnityUtils.instanceFlag);
static MethodInfo m_Nailgun_Shoot_ModifyNail = typeof(Nailgun_Shoot).GetMethod("ModifyNail", UnityUtils.staticFlag);
static MethodInfo m_Transform_set_forward = typeof(Transform).GetProperty("forward", UnityUtils.instanceFlag).GetSetMethod();
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction localObjectStoreInst = null;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && code[i].OperandIs(f_Nailgun_nail))
{
for (; i < code.Count; i++)
if (ILUtils.IsStoreLocalOpcode(code[i].opcode))
break;
localObjectStoreInst = code[i];
}
}
Debug.Log($"Nail local reference: {ILUtils.TurnInstToString(localObjectStoreInst)}");
int insertIndex = 0;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_Transform_set_forward))
{
insertIndex = i + 1;
break;
}
}
// Push instance reference
code.Insert(insertIndex, new CodeInstruction(OpCodes.Ldarg_0));
insertIndex += 1;
// Push local nail object
code.Insert(insertIndex, new CodeInstruction(ILUtils.GetLoadLocalFromStoreLocal(localObjectStoreInst.opcode), localObjectStoreInst.operand));
insertIndex += 1;
// Call the method
code.Insert(insertIndex, new CodeInstruction(OpCodes.Call, m_Nailgun_Shoot_ModifyNail));
return code.AsEnumerable();
}
}
class Nailgun_SuperSaw
{
public static void ModifySupersaw(GameObject supersaw)
{
Nail saw = supersaw.GetComponent<Nail>();
saw.damage = ConfigManager.sawGreenBurningDamage.value;
saw.hitAmount = ConfigManager.sawGreenBurningHitAmount.value;
}
static FieldInfo f_Nailgun_heatedNail = typeof(Nailgun).GetField("heatedNail", UnityUtils.instanceFlag);
static MethodInfo m_Nailgun_SuperSaw_ModifySupersaw = typeof(Nailgun_SuperSaw).GetMethod("ModifySupersaw", UnityUtils.staticFlag);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction localObjectStoreInst = null;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && code[i].OperandIs(f_Nailgun_heatedNail))
{
for (; i < code.Count; i++)
if (ILUtils.IsStoreLocalOpcode(code[i].opcode))
break;
localObjectStoreInst = code[i];
}
}
Debug.Log($"Supersaw local reference: {ILUtils.TurnInstToString(localObjectStoreInst)}");
int insertIndex = code.Count - 1;
// Push local nail object
code.Insert(insertIndex, new CodeInstruction(ILUtils.GetLoadLocalFromStoreLocal(localObjectStoreInst.opcode), localObjectStoreInst.operand));
insertIndex += 1;
// Call the method
code.Insert(insertIndex, new CodeInstruction(OpCodes.Call, m_Nailgun_SuperSaw_ModifySupersaw));
return code.AsEnumerable();
}
}
class NailGun_Update
{
static bool Prefix(Nailgun __instance, ref float ___heatSinks)
{
if(__instance.variation == 0)
{
float maxSinks = (__instance.altVersion ? 1f : 2f);
float multi = (__instance.altVersion ? ConfigManager.sawHeatsinkRegSpeedMulti.value : ConfigManager.nailgunHeatsinkRegSpeedMulti.value);
float rate = 0.125f;
if (___heatSinks < maxSinks && multi != 1)
___heatSinks = Mathf.Min(maxSinks, ___heatSinks + Time.deltaTime * rate * (multi - 1f));
}
return true;
}
}
class NewMovement_Update
{
static bool Prefix(NewMovement __instance, int ___difficulty)
{
if (__instance.boostCharge < 300f && !__instance.sliding && !__instance.slowMode)
{
float multi = 1f;
if (___difficulty == 1)
multi = 1.5f;
else if (___difficulty == 0f)
multi = 2f;
__instance.boostCharge = Mathf.Min(300f, __instance.boostCharge + Time.deltaTime * 70f * multi * (ConfigManager.staminaRegSpeedMulti.value - 1f));
}
return true;
}
}
class WeaponCharges_Charge
{
static bool Prefix(WeaponCharges __instance, float __0)
{
if (__instance.rev1charge < 400f)
__instance.rev1charge = Mathf.Min(400f, __instance.rev1charge + 25f * __0 * (ConfigManager.coinRegSpeedMulti.value - 1f));
if (__instance.rev2charge < 300f)
__instance.rev2charge = Mathf.Min(300f, __instance.rev2charge + (__instance.rev2alt ? 35f : 15f) * __0 * (ConfigManager.sharpshooterRegSpeedMulti.value - 1f));
if(!__instance.naiAmmoDontCharge)
{
if (__instance.naiAmmo < 100f)
__instance.naiAmmo = Mathf.Min(100f, __instance.naiAmmo + __0 * 3.5f * (ConfigManager.nailgunAmmoRegSpeedMulti.value - 1f)); ;
if (__instance.naiSaws < 10f)
__instance.naiSaws = Mathf.Min(10f, __instance.naiSaws + __0 * 0.5f * (ConfigManager.sawAmmoRegSpeedMulti.value - 1f));
}
if (__instance.raicharge < 5f)
__instance.raicharge = Mathf.Min(5f, __instance.raicharge + __0 * 0.25f * (ConfigManager.railcannonRegSpeedMulti.value - 1f));
if (!__instance.rocketFrozen && __instance.rocketFreezeTime < 5f)
__instance.rocketFreezeTime = Mathf.Min(5f, __instance.rocketFreezeTime + __0 * 0.5f * (ConfigManager.rocketFreezeRegSpeedMulti.value - 1f));
if (__instance.rocketCannonballCharge < 1f)
__instance.rocketCannonballCharge = Mathf.Min(1f, __instance.rocketCannonballCharge + __0 * 0.125f * (ConfigManager.rocketCannonballRegSpeedMulti.value - 1f));
return true;
}
}
class NewMovement_GetHurt
{
static bool Prefix( | NewMovement __instance, out float __state)
{ |
__state = __instance.antiHp;
return true;
}
static void Postfix(NewMovement __instance, float __state)
{
float deltaAnti = __instance.antiHp - __state;
if (deltaAnti <= 0)
return;
deltaAnti *= ConfigManager.hardDamagePercent.normalizedValue;
__instance.antiHp = __state + deltaAnti;
}
static FieldInfo hpField = typeof(NewMovement).GetField("hp");
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && (FieldInfo)code[i].operand == hpField)
{
i += 1;
if (code[i].opcode == OpCodes.Ldc_I4_S)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == (Single)99f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.maxPlayerHp.value - 1));
}
}
return code.AsEnumerable();
}
}
class HookArm_FixedUpdate
{
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 66f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(66f * (ConfigManager.maxPlayerHp.value / 100f) * ConfigManager.whiplashHardDamageSpeed.value));
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 50f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.whiplashHardDamageCap.value));
}
}
return code.AsEnumerable();
}
}
class NewMovement_ForceAntiHP
{
static FieldInfo hpField = typeof(NewMovement).GetField("hp");
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && (FieldInfo)code[i].operand == hpField)
{
i += 1;
if (i < code.Count && code[i].opcode == OpCodes.Ldc_I4_S && (SByte)code[i].operand == (SByte)100)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
else if (code[i].opcode == OpCodes.Ldarg_1)
{
i += 2;
if (i < code.Count && code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 99f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.maxPlayerHp.value - 1));
}
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 100f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)ConfigManager.maxPlayerHp.value);
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 50f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)ConfigManager.maxPlayerHp.value / 2);
}
else if (code[i].opcode == OpCodes.Ldc_I4_S && (SByte)code[i].operand == (SByte)100)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
return code.AsEnumerable();
}
}
class NewMovement_GetHealth
{
static bool Prefix(NewMovement __instance, int __0, bool __1, ref AudioSource ___greenHpAud, Canvas ___fullHud)
{
if (__instance.dead || __instance.exploded)
return false;
int maxHp = Mathf.RoundToInt(ConfigManager.maxPlayerHp.value - __instance.antiHp);
int maxDelta = maxHp - __instance.hp;
if (maxDelta <= 0)
return true;
if (!__1 && __0 > 5 && MonoSingleton<PrefsManager>.Instance.GetBoolLocal("bloodEnabled", false))
{
GameObject.Instantiate<GameObject>(__instance.scrnBlood, ___fullHud.transform);
}
__instance.hp = Mathf.Min(maxHp, __instance.hp + __0);
__instance.hpFlash.Flash(1f);
if (!__1 && __0 > 5)
{
if (___greenHpAud == null)
{
___greenHpAud = __instance.hpFlash.GetComponent<AudioSource>();
}
___greenHpAud.Play();
}
return false;
}
}
class NewMovement_SuperCharge
{
static bool Prefix(NewMovement __instance)
{
__instance.hp = Mathf.Max(ConfigManager.maxPlayerHp.value, ConfigManager.playerHpSupercharge.value);
return false;
}
}
class NewMovement_Respawn
{
static void Postfix(NewMovement __instance)
{
__instance.hp = ConfigManager.maxPlayerHp.value;
}
}
class NewMovement_DeltaHpComp : MonoBehaviour
{
public static NewMovement_DeltaHpComp instance;
private NewMovement player;
private AudioSource hurtAud;
private bool levelMap = false;
private void Awake()
{
instance = this;
player = NewMovement.Instance;
hurtAud = player.hurtScreen.GetComponent<AudioSource>();
levelMap = SceneHelper.CurrentLevelNumber > 0;
UpdateEnabled();
}
public void UpdateEnabled()
{
if (!ConfigManager.playerHpDeltaToggle.value)
enabled = false;
if (SceneHelper.CurrentScene == "uk_construct")
enabled = ConfigManager.playerHpDeltaSandbox.value;
else if (SceneHelper.CurrentScene == "Endless")
enabled = ConfigManager.playerHpDeltaCybergrind.value;
else
{
enabled = SceneHelper.CurrentLevelNumber > 0;
}
}
public void ResetCooldown()
{
deltaCooldown = ConfigManager.playerHpDeltaDelay.value;
}
public float deltaCooldown = ConfigManager.playerHpDeltaDelay.value;
public void Update()
{
if (player.dead || !ConfigManager.playerHpDeltaToggle.value || !StatsManager.Instance.timer)
{
ResetCooldown();
return;
}
if (levelMap)
{
// Calm
if (MusicManager.Instance.requestedThemes == 0)
{
if (!ConfigManager.playerHpDeltaCalm.value)
{
ResetCooldown();
return;
}
}
// Combat
else
{
if (!ConfigManager.playerHpDeltaCombat.value)
{
ResetCooldown();
return;
}
}
}
deltaCooldown = Mathf.MoveTowards(deltaCooldown, 0f, Time.deltaTime);
if (deltaCooldown == 0f)
{
ResetCooldown();
int deltaHp = ConfigManager.playerHpDeltaAmount.value;
int limit = ConfigManager.playerHpDeltaLimit.value;
if (deltaHp == 0)
return;
if (deltaHp > 0)
{
if (player.hp > limit)
return;
player.GetHealth(deltaHp, true);
}
else
{
if (player.hp < limit)
return;
if (player.hp - deltaHp <= 0)
player.GetHurt(-deltaHp, false, 0, false, false);
else
{
player.hp += deltaHp;
if (ConfigManager.playerHpDeltaHurtAudio.value)
{
hurtAud.pitch = UnityEngine.Random.Range(0.8f, 1f);
hurtAud.PlayOneShot(hurtAud.clip);
}
}
}
}
}
}
class NewMovement_Start
{
static void Postfix(NewMovement __instance)
{
__instance.gameObject.AddComponent<NewMovement_DeltaHpComp>();
__instance.hp = ConfigManager.maxPlayerHp.value;
}
}
class HealthBarTracker : MonoBehaviour
{
public static List<HealthBarTracker> instances = new List<HealthBarTracker>();
private HealthBar hb;
private void Awake()
{
if (hb == null)
hb = GetComponent<HealthBar>();
instances.Add(this);
for (int i = instances.Count - 1; i >= 0; i--)
{
if (instances[i] == null)
instances.RemoveAt(i);
}
}
private void OnDestroy()
{
if (instances.Contains(this))
instances.Remove(this);
}
public void SetSliderRange()
{
if (hb == null)
hb = GetComponent<HealthBar>();
if (hb.hpSliders.Length != 0)
{
hb.hpSliders[0].maxValue = hb.afterImageSliders[0].maxValue = ConfigManager.maxPlayerHp.value;
hb.hpSliders[1].minValue = hb.afterImageSliders[1].minValue = ConfigManager.maxPlayerHp.value;
hb.hpSliders[1].maxValue = hb.afterImageSliders[1].maxValue = Mathf.Max(ConfigManager.maxPlayerHp.value, ConfigManager.playerHpSupercharge.value);
hb.antiHpSlider.maxValue = ConfigManager.maxPlayerHp.value;
}
}
}
class HealthBar_Start
{
static void Postfix(HealthBar __instance)
{
__instance.gameObject.AddComponent<HealthBarTracker>().SetSliderRange();
}
}
class HealthBar_Update
{
static FieldInfo f_HealthBar_hp = typeof(HealthBar).GetField("hp", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static FieldInfo f_HealthBar_antiHp = typeof(HealthBar).GetField("antiHp", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
CodeInstruction inst = code[i];
if (inst.opcode == OpCodes.Ldc_R4 && code[i - 1].OperandIs(f_HealthBar_hp))
{
float operand = (Single)inst.operand;
if (operand == 30f)
code[i].operand = (Single)(ConfigManager.maxPlayerHp.value * 0.3f);
else if (operand == 50f)
code[i].operand = (Single)(ConfigManager.maxPlayerHp.value * 0.5f);
}
else if (inst.opcode == OpCodes.Ldstr)
{
string operand = (string)inst.operand;
if (operand == "/200")
code[i].operand = $"/{ConfigManager.playerHpSupercharge}";
}
else if (inst.opcode == OpCodes.Ldc_R4 && i + 2 < code.Count && code[i + 2].OperandIs(f_HealthBar_antiHp))
{
code[i].operand = (Single)ConfigManager.maxPlayerHp.value;
}
}
return code.AsEnumerable();
}
}
}
| Ultrapain/Patches/PlayerStatTweaks.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/MinosPrime.cs",
"retrieved_chunk": " string clipname = ___anim.GetCurrentAnimatorClipInfo(0)[0].clip.name;\n if (clipname != \"Combo\" || UnityEngine.Random.Range(0, 99.9f) > ConfigManager.minosPrimeComboExplosiveEndChance.value)\n return true;\n ___anim.Play(\"Dropkick\", 0, (1.0815f - 0.4279f) / 2.65f);\n return false;\n }\n }\n class MinosPrime_Ascend\n {\n static bool Prefix(MinosPrime __instance, EnemyIdentifier ___eid, Animator ___anim, ref bool ___vibrating)",
"score": 0.7831200957298279
},
{
"filename": "Ultrapain/Patches/FleshPrison.cs",
"retrieved_chunk": " InsigniaZ.transform.eulerAngles = new Vector3(0, MonoSingleton<PlayerTracker>.Instance.GetTarget().transform.rotation.eulerAngles.y, 0);\n InsigniaZ.transform.Rotate(new Vector3(0, 0, 90), Space.Self);\n if (___fleshDroneCooldown < 1f)\n {\n ___fleshDroneCooldown = 1f;\n }\n return false;\n }\n }*/\n}",
"score": 0.7710146903991699
},
{
"filename": "Ultrapain/Patches/StreetCleaner.cs",
"retrieved_chunk": " }\n static void Postfix(Streetcleaner __instance, ref float ___dodgeCooldown)\n {\n if(didDodge)\n ___dodgeCooldown = UnityEngine.Random.Range(0f, 1f);\n }\n }*/\n class BulletCheck_OnTriggerEnter_Patch\n {\n static void Postfix(BulletCheck __instance, Collider __0/*, EnemyIdentifier ___eid*/)",
"score": 0.7667827606201172
},
{
"filename": "Ultrapain/Patches/Ferryman.cs",
"retrieved_chunk": " {\n // time = 0.8347\n // total = 2.4667\n ___anim.Play(\"OarCombo\", 0, (0.8347f * (1f - ConfigManager.ferrymanAttackDelay.value)) / 2.4667f);\n SnapToGround.Invoke(__instance, new object[0]);\n ___inAction = true;\n ___tracking = true;\n if (___nma.isOnNavMesh)\n {\n ___nma.SetDestination(__instance.transform.position);",
"score": 0.7600038051605225
},
{
"filename": "Ultrapain/Patches/Mindflayer.cs",
"retrieved_chunk": " componentInChildren.target = MonoSingleton<PlayerTracker>.Instance.GetTarget();\n componentInChildren.safeEnemyType = EnemyType.Mindflayer;\n componentInChildren.damage *= ___eid.totalDamageModifier;\n }\n __instance.chargeParticle.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);\n __instance.cooldown = (float)UnityEngine.Random.Range(4, 5);\n return false;*/\n MindflayerPatch counter = __instance.GetComponent<MindflayerPatch>();\n if (counter == null)\n return true;",
"score": 0.7577306032180786
}
] | csharp | NewMovement __instance, out float __state)
{ |
using System;
using Sandland.SceneTool.Editor.Common.Data;
using Sandland.SceneTool.Editor.Common.Utils;
using UnityEditor;
using UnityEngine.UIElements;
namespace Sandland.SceneTool.Editor.Views
{
internal class ThemeDisplay : RadioButton, IDisposable
{
public event Action<AssetFileInfo> Selected;
private readonly AssetFileInfo _themeInfo;
public ThemeDisplay( | AssetFileInfo themeInfo) : base()
{ |
_themeInfo = themeInfo;
var visualTree = AssetDatabaseUtils.FindAndLoadVisualTreeAsset(nameof(ThemeDisplay));
visualTree.CloneTree(this);
AddToClassList("sandland-theme-button");
var mainStyleSheet = AssetDatabaseUtils.FindAndLoadStyleSheet(nameof(ThemeDisplay));
var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(themeInfo.Path);
styleSheets.Add(mainStyleSheet);
styleSheets.Add(styleSheet);
label = themeInfo.Name;
this.RegisterValueChangedCallback(OnValueChanged);
}
private void OnValueChanged(ChangeEvent<bool> evt)
{
if (!evt.newValue)
{
return;
}
Selected?.Invoke(_themeInfo);
}
public void Dispose()
{
this.UnregisterValueChangedCallback(OnValueChanged);
}
}
} | Assets/SceneTools/Editor/Views/SceneToolsSetupWindow/ThemeDisplay/ThemeDisplay.cs | migus88-Sandland.SceneTools-64e9f8c | [
{
"filename": "Assets/SceneTools/Editor/Common/Data/SceneInfo.cs",
"retrieved_chunk": "using System.Collections.Generic;\nnamespace Sandland.SceneTool.Editor.Common.Data\n{\n internal class SceneInfo : AssetFileInfo\n {\n public int BuildIndex { get; set; }\n public string Address { get; set; }\n public SceneImportType ImportType { get; set; }\n private SceneInfo(string name, string path, string guid, string bundleName, List<string> labels) : base(name, path, guid, bundleName, labels)\n {",
"score": 0.8524999618530273
},
{
"filename": "Assets/SceneTools/Editor/Listeners/SceneClassGenerationListener.cs",
"retrieved_chunk": "using UnityEditor.AddressableAssets.Settings;\n#endif\nnamespace Sandland.SceneTool.Editor.Listeners\n{\n internal static class SceneClassGenerationListener\n {\n [InitializeOnLoadMethod]\n private static void Initialize()\n {\n EditorBuildSettings.sceneListChanged += GenerateScenesClass;",
"score": 0.8397958278656006
},
{
"filename": "Assets/SceneTools/Editor/Views/SceneSelectorWindow/FavoritesButton/FavoritesButton.cs",
"retrieved_chunk": " private const string FavoriteClassName = \"favorite\";\n public bool IsFavorite { get; private set; }\n //private Image _starImage;\n private AssetFileInfo _fileInfo;\n public FavoritesButton()\n {\n this.AddManipulator(new Clickable(OnClick));\n }\n public void Init(AssetFileInfo info)\n {",
"score": 0.8204339742660522
},
{
"filename": "Assets/SceneTools/Editor/Views/SceneToolsSetupWindow/Handlers/ISceneToolsSetupUiHandler.cs",
"retrieved_chunk": "using System;\nnamespace Sandland.SceneTool.Editor.Views.Handlers\n{\n internal interface ISceneToolsSetupUiHandler\n {\n void SubscribeToEvents();\n void UnsubscribeFromEvents();\n void Apply();\n }\n}",
"score": 0.8140393495559692
},
{
"filename": "Assets/SceneTools/Editor/Common/Utils/AssetDatabaseUtils.cs",
"retrieved_chunk": "namespace Sandland.SceneTool.Editor.Common.Utils\n{\n internal static class AssetDatabaseUtils\n {\n public static VisualTreeAsset FindAndLoadVisualTreeAsset(string name = null) =>\n FindAndLoadAsset<VisualTreeAsset>(name);\n public static StyleSheet FindAndLoadStyleSheet(string name = null) => FindAndLoadAsset<StyleSheet>(name);\n public static bool TryFindAndLoadAsset<T>(out T result, string name = null) where T : Object\n {\n try",
"score": 0.8074440360069275
}
] | csharp | AssetFileInfo themeInfo) : base()
{ |
/*
Copyright (c) 2023 Xavier Arpa López Thomas Peter ('Kingdox')
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
using System;
using System.Collections.Generic;
using UnityEngine;
using Kingdox.UniFlux.Core;
namespace Kingdox.UniFlux.Benchmark
{
public class Benchmark_UniFlux : MonoFlux
{
[SerializeField] private Marker _m_store_string_add = new Marker()
{
K = "store<string,Action> ADD"
};
[SerializeField] private Marker _m_store_int_add = new Marker()
{
K = "store<int,Action> ADD"
};
[SerializeField] private Marker _m_store_byte_add = new Marker()
{
K = "store<byte,Action> ADD"
};
[SerializeField] private | Marker _m_store_bool_add = new Marker()
{ |
K = "store<bool,Action> ADD"
};
[SerializeField] private Marker _m_store_string_remove = new Marker()
{
K = "store<string,Action> REMOVE"
};
[SerializeField] private Marker _m_store_int_remove = new Marker()
{
K = "store<int,Action> REMOVE"
};
[SerializeField] private Marker _m_store_byte_remove = new Marker()
{
K = "store<byte,Action> REMOVE"
};
[SerializeField] private Marker _m_store_bool_remove = new Marker()
{
K = "store<bool,Action> REMOVE"
};
[SerializeField] private Marker _m_dispatch_string = new Marker()
{
K = $"dispatch<string>"
};
[SerializeField] private Marker _m_dispatch_int = new Marker()
{
K = $"dispatch<int>"
};
[SerializeField] private Marker _m_dispatch_byte = new Marker()
{
K = $"dispatch<byte>"
};
[SerializeField] private Marker _m_dispatch_bool = new Marker()
{
K = $"dispatch<bool>"
};
private const byte __m_store = 52;
private const byte __m_dispatch = 250;
private Rect rect_area;
private readonly Lazy<GUIStyle> _style = new Lazy<GUIStyle>(() => new GUIStyle("label")
{
fontSize = 28,
alignment = TextAnchor.MiddleLeft,
padding = new RectOffset(10, 0, 0, 0)
});
[SerializeField] private int _iterations = default;
[SerializeField] private List<string> _Results = default;
public bool draw=true;
public bool isUpdated = false;
public bool isUpdated_store = false;
public bool isUpdated_dispatch = false;
protected override void OnFlux(in bool condition)
{
StoreTest_Add();
StoreTest_Remove();
}
public void Start()
{
DispatchTest();
}
private void Update()
{
if(!isUpdated) return;
if(isUpdated_store) StoreTest_Add();
if(isUpdated_store) StoreTest_Remove();
if(isUpdated_dispatch) DispatchTest();
}
private void StoreTest_Add()
{
// Store String
if(_m_store_string_add.Execute)
{
_m_store_string_add.iteration=_iterations;
_m_store_string_add.Begin();
for (int i = 0; i < _iterations; i++)
{
"Store".Store(Example_OnFlux, true);
}
_m_store_string_add.End();
}
// Store Int
if(_m_store_int_add.Execute)
{
_m_store_int_add.iteration=_iterations;
_m_store_int_add.Begin();
for (int i = 0; i < _iterations; i++)
{
42.Store(Example_OnFlux, true);
}
_m_store_int_add.End();
}
// Store Byte
if(_m_store_byte_add.Execute)
{
_m_store_byte_add.iteration=_iterations;
_m_store_byte_add.Begin();
for (int i = 0; i < _iterations; i++)
{
Flux.Store(__m_store, Example_OnFlux, true);
}
_m_store_byte_add.End();
}
// Store Bool
if(_m_store_bool_add.Execute)
{
_m_store_bool_add.iteration=_iterations;
_m_store_bool_add.Begin();
for (int i = 0; i < _iterations; i++)
{
Flux.Store(true, Example_OnFlux, true);
}
_m_store_bool_add.End();
}
}
private void StoreTest_Remove()
{
// Store String
if(_m_store_string_remove.Execute)
{
_m_store_string_remove.iteration=_iterations;
_m_store_string_remove.Begin();
for (int i = 0; i < _iterations; i++)
{
"Store".Store(Example_OnFlux, false);
}
_m_store_string_remove.End();
}
// Store Int
if(_m_store_int_remove.Execute)
{
_m_store_int_remove.iteration=_iterations;
_m_store_int_remove.Begin();
for (int i = 0; i < _iterations; i++)
{
42.Store(Example_OnFlux, false);
}
_m_store_int_remove.End();
}
// Store Byte
if(_m_store_byte_remove.Execute)
{
_m_store_byte_remove.iteration=_iterations;
_m_store_byte_remove.Begin();
for (int i = 0; i < _iterations; i++)
{
Flux.Store(__m_store, Example_OnFlux, false);
}
_m_store_byte_remove.End();
}
// Store Bool
if(_m_store_bool_remove.Execute)
{
_m_store_bool_remove.iteration=_iterations;
_m_store_bool_remove.Begin();
for (int i = 0; i < _iterations; i++)
{
Flux.Store(true, Example_OnFlux, false);
}
_m_store_bool_remove.End();
}
}
private void DispatchTest()
{
// Dispatch String
if(_m_dispatch_string.Execute)
{
_m_dispatch_string.iteration=_iterations;
_m_dispatch_string.Begin();
for (int i = 0; i < _iterations; i++) "UniFlux.Dispatch".Dispatch();
_m_dispatch_string.End();
}
// Dispatch Int
if(_m_dispatch_int.Execute)
{
_m_dispatch_int.iteration=_iterations;
_m_dispatch_int.Begin();
for (int i = 0; i < _iterations; i++) 0.Dispatch();
_m_dispatch_int.End();
}
// Dispatch Byte
if(_m_dispatch_byte.Execute)
{
_m_dispatch_byte.iteration=_iterations;
_m_dispatch_byte.Begin();
for (int i = 0; i < _iterations; i++) Flux.Dispatch(__m_dispatch);
_m_dispatch_byte.End();
}
// Dispatch Boolean
if(_m_dispatch_bool.Execute)
{
_m_dispatch_bool.iteration=_iterations;
_m_dispatch_bool.Begin();
for (int i = 0; i < _iterations; i++) Flux.Dispatch(true);
_m_dispatch_bool.End();
}
}
[Flux("UniFlux.Dispatch")] private void Example_Dispatch_String(){}
[Flux("UniFlux.Dispatch")] private void Example_Dispatch_String2(){}
[Flux(0)] private void Example_Dispatch_Int(){}
[Flux(__m_dispatch)] private void Example_Dispatch_Byte(){}
[Flux(false)] private void Example_Dispatch_Boolean_2(){}
[Flux(false)] private void Example_Dispatch_Boolean_3(){}
[Flux(false)] private void Example_Dispatch_Boolean_4(){}
[Flux(false)] private void Example_Dispatch_Boolean_5(){}
[Flux(false)] private void Example_Dispatch_Boolean_6(){}
[Flux(true)] private void Example_Dispatch_Boolean(){}
private void Example_OnFlux(){}
private void OnGUI()
{
if(!draw)return;
_Results.Clear();
_Results.Add(_m_store_string_add.Visual);
_Results.Add(_m_store_int_add.Visual);
_Results.Add(_m_store_byte_add.Visual);
_Results.Add(_m_store_bool_add.Visual);
_Results.Add(_m_store_string_remove.Visual);
_Results.Add(_m_store_int_remove.Visual);
_Results.Add(_m_store_byte_remove.Visual);
_Results.Add(_m_store_bool_remove.Visual);
_Results.Add(_m_dispatch_string.Visual);
_Results.Add(_m_dispatch_int.Visual);
_Results.Add(_m_dispatch_byte.Visual);
_Results.Add(_m_dispatch_bool.Visual);
var height = (float) Screen.height / 2;
for (int i = 0; i < _Results.Count; i++)
{
rect_area = new Rect(0, _style.Value.lineHeight * i, Screen.width, height);
GUI.Label(rect_area, _Results[i], _style.Value);
}
}
}
} | Benchmark/General/Benchmark_UniFlux.cs | xavierarpa-UniFlux-a2d46de | [
{
"filename": "Benchmark/Nest/Benchmark_Nest_UniFlux.cs",
"retrieved_chunk": " private void Store_1() => \"2\".Dispatch();\n private void Store_2() => \"3\".Dispatch();\n private void Store_3() => \"4\".Dispatch();\n private void Store_4() => \"5\".Dispatch();\n private void Store_5() {}\n private void Sample()\n {\n if (_mark_fluxAttribute.Execute)\n {\n _mark_fluxAttribute.iteration = iteration;",
"score": 0.7805715799331665
},
{
"filename": "Tests/EditMode/EditMode_Test_1.cs",
"retrieved_chunk": " Flux.Store<string, int>(\"OnTest\", OnTest_Func, false);\n }\n [Test] public void UnsubscribeFuncParam()\n {\n Flux.Store<string, float, float>(\"OnTest\", OnTest_FuncPatam, false);\n }\n public void OnTest_Action() {}\n public void OnTest_ActionParam(bool condition) {}\n public int OnTest_Func() => 1;\n public float OnTest_FuncPatam(float value) => value;",
"score": 0.7688083648681641
},
{
"filename": "Tests/EditMode/EditMode_Test_1.cs",
"retrieved_chunk": " Flux.Dispatch(\"OnTest\", true);\n }\n [Test] public void DispatchFunc()\n {\n var val = Flux.Dispatch<string,int>(\"OnTest\");\n }\n [Test] public void DispatchFuncParam()\n {\n var val_2 = Flux.Dispatch<string, float, float>(\"OnTest\", 3f);\n }",
"score": 0.7550820112228394
},
{
"filename": "Tests/EditMode/EditMode_Test_1.cs",
"retrieved_chunk": " Flux.Store(\"OnTest\", OnTest_Action, true);\n }\n [Test] public void SubscribeActionParam()\n {\n Flux.Store<string,bool>(\"OnTest\", OnTest_ActionParam, true);\n }\n [Test] public void SubscribeFunc()\n {\n Flux.Store<string, int>(\"OnTest\", OnTest_Func, true);\n }",
"score": 0.7522140145301819
},
{
"filename": "Tests/EditMode/EditMode_Test_1.cs",
"retrieved_chunk": " [Test] public void SubscribeFuncParam()\n {\n Flux.Store<string,float,float>(\"OnTest\", OnTest_FuncPatam, true);\n }\n [Test] public void DispatchAction()\n {\n Flux.Dispatch(\"OnTest\");\n }\n [Test] public void DispatchActionParam()\n {",
"score": 0.7511614561080933
}
] | csharp | Marker _m_store_bool_add = new Marker()
{ |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace csharp_test_client
{
public partial class mainForm : Form
{
ClientSimpleTcp Network = new ClientSimpleTcp();
bool IsNetworkThreadRunning = false;
bool IsBackGroundProcessRunning = false;
System.Threading.Thread NetworkReadThread = null;
System.Threading.Thread NetworkSendThread = null;
PacketBufferManager PacketBuffer = new PacketBufferManager();
Queue<PacketData> RecvPacketQueue = new Queue<PacketData>();
Queue<byte[]> SendPacketQueue = new Queue<byte[]>();
System.Windows.Threading.DispatcherTimer dispatcherUITimer;
public mainForm()
{
InitializeComponent();
}
private void mainForm_Load(object sender, EventArgs e)
{
PacketBuffer.Init((8096 * 10), PacketDef.PACKET_HEADER_SIZE, 1024);
IsNetworkThreadRunning = true;
NetworkReadThread = new System.Threading.Thread(this.NetworkReadProcess);
NetworkReadThread.Start();
NetworkSendThread = new System.Threading.Thread(this.NetworkSendProcess);
NetworkSendThread.Start();
IsBackGroundProcessRunning = true;
dispatcherUITimer = new System.Windows.Threading.DispatcherTimer();
dispatcherUITimer.Tick += new EventHandler(BackGroundProcess);
dispatcherUITimer.Interval = new TimeSpan(0, 0, 0, 0, 100);
dispatcherUITimer.Start();
btnDisconnect.Enabled = false;
SetPacketHandler();
DevLog.Write("프로그램 시작 !!!", LOG_LEVEL.INFO);
}
private void mainForm_FormClosing(object sender, FormClosingEventArgs e)
{
IsNetworkThreadRunning = false;
IsBackGroundProcessRunning = false;
Network.Close();
}
private void btnConnect_Click(object sender, EventArgs e)
{
string address = textBoxIP.Text;
if (checkBoxLocalHostIP.Checked)
{
address = "127.0.0.1";
}
int port = Convert.ToInt32(textBoxPort.Text);
if (Network.Connect(address, port))
{
labelStatus.Text = string.Format("{0}. 서버에 접속 중", DateTime.Now);
btnConnect.Enabled = false;
btnDisconnect.Enabled = true;
DevLog.Write($"서버에 접속 중", LOG_LEVEL.INFO);
}
else
{
labelStatus.Text = string.Format("{0}. 서버에 접속 실패", DateTime.Now);
}
}
private void btnDisconnect_Click(object sender, EventArgs e)
{
SetDisconnectd();
Network.Close();
}
private void button1_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(textSendText.Text))
{
MessageBox.Show("보낼 텍스트를 입력하세요");
return;
}
var body = Encoding.UTF8.GetBytes(textSendText.Text);
List<byte> dataSource = new List<byte>();
dataSource.AddRange(BitConverter.GetBytes((UInt16)(body.Length + PacketDef.PACKET_HEADER_SIZE)));
dataSource.AddRange(BitConverter.GetBytes((UInt16)PACKET_ID.DEV_ECHO));
dataSource.AddRange(new byte[] { (byte)0 });
dataSource.AddRange(body);
SendPacketQueue.Enqueue(dataSource.ToArray());
}
void NetworkReadProcess()
{
const Int16 PacketHeaderSize = PacketDef.PACKET_HEADER_SIZE;
while (IsNetworkThreadRunning)
{
if (Network.IsConnected() == false)
{
System.Threading.Thread.Sleep(1);
continue;
}
var recvData = Network.Receive();
if (recvData != null)
{
PacketBuffer.Write(recvData.Item2, 0, recvData.Item1);
while (true)
{
var data = PacketBuffer.Read();
if (data.Count < 1)
{
break;
}
var packet = new PacketData();
packet.DataSize = (short)(data.Count - PacketHeaderSize);
packet.PacketID = BitConverter.ToInt16(data.Array, data.Offset + 2);
packet.Type = (SByte)data.Array[(data.Offset + 4)];
packet.BodyData = new byte[packet.DataSize];
Buffer.BlockCopy(data.Array, (data.Offset + PacketHeaderSize), packet.BodyData, 0, (data.Count - PacketHeaderSize));
lock (((System.Collections.ICollection)RecvPacketQueue).SyncRoot)
{
RecvPacketQueue.Enqueue(packet);
}
}
DevLog.Write($"받은 데이터 크기: {recvData.Item1}", LOG_LEVEL.INFO);
}
else
{
Network.Close();
SetDisconnectd();
DevLog.Write("서버와 접속 종료 !!!", LOG_LEVEL.INFO);
}
}
}
void NetworkSendProcess()
{
while (IsNetworkThreadRunning)
{
System.Threading.Thread.Sleep(1);
if (Network.IsConnected() == false)
{
continue;
}
lock (((System.Collections.ICollection)SendPacketQueue).SyncRoot)
{
if (SendPacketQueue.Count > 0)
{
var packet = SendPacketQueue.Dequeue();
Network.Send(packet);
}
}
}
}
void BackGroundProcess(object sender, EventArgs e)
{
ProcessLog();
try
{
var packet = new PacketData();
lock (((System.Collections.ICollection)RecvPacketQueue).SyncRoot)
{
if (RecvPacketQueue.Count() > 0)
{
packet = RecvPacketQueue.Dequeue();
}
}
if (packet.PacketID != 0)
{
PacketProcess(packet);
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("ReadPacketQueueProcess. error:{0}", ex.Message));
}
}
private void ProcessLog()
{
// 너무 이 작업만 할 수 없으므로 일정 작업 이상을 하면 일단 패스한다.
int logWorkCount = 0;
while (IsBackGroundProcessRunning)
{
System.Threading.Thread.Sleep(1);
string msg;
if (DevLog.GetLog(out msg))
{
++logWorkCount;
if (listBoxLog.Items.Count > 512)
{
listBoxLog.Items.Clear();
}
listBoxLog.Items.Add(msg);
listBoxLog.SelectedIndex = listBoxLog.Items.Count - 1;
}
else
{
break;
}
if (logWorkCount > 8)
{
break;
}
}
}
public void SetDisconnectd()
{
if (btnConnect.Enabled == false)
{
btnConnect.Enabled = true;
btnDisconnect.Enabled = false;
}
SendPacketQueue.Clear();
listBoxRoomChatMsg.Items.Clear();
listBoxRoomUserList.Items.Clear();
labelStatus.Text = "서버 접속이 끊어짐";
}
public void PostSendPacket( | PACKET_ID packetID, byte[] bodyData)
{ |
if (Network.IsConnected() == false)
{
DevLog.Write("서버 연결이 되어 있지 않습니다", LOG_LEVEL.ERROR);
return;
}
Int16 bodyDataSize = 0;
if (bodyData != null)
{
bodyDataSize = (Int16)bodyData.Length;
}
var packetSize = bodyDataSize + PacketDef.PACKET_HEADER_SIZE;
List<byte> dataSource = new List<byte>();
dataSource.AddRange(BitConverter.GetBytes((UInt16)packetSize));
dataSource.AddRange(BitConverter.GetBytes((UInt16)packetID));
dataSource.AddRange(new byte[] { (byte)0 });
if (bodyData != null)
{
dataSource.AddRange(bodyData);
}
SendPacketQueue.Enqueue(dataSource.ToArray());
}
void AddRoomUserList(Int64 userUniqueId, string userID)
{
var msg = $"{userUniqueId}: {userID}";
listBoxRoomUserList.Items.Add(msg);
}
void RemoveRoomUserList(Int64 userUniqueId)
{
object removeItem = null;
foreach( var user in listBoxRoomUserList.Items)
{
var items = user.ToString().Split(":");
if( items[0].ToInt64() == userUniqueId)
{
removeItem = user;
return;
}
}
if (removeItem != null)
{
listBoxRoomUserList.Items.Remove(removeItem);
}
}
// 로그인 요청
private void button2_Click(object sender, EventArgs e)
{
var loginReq = new LoginReqPacket();
loginReq.SetValue(textBoxUserID.Text, textBoxUserPW.Text);
PostSendPacket(PACKET_ID.LOGIN_REQ, loginReq.ToBytes());
DevLog.Write($"로그인 요청: {textBoxUserID.Text}, {textBoxUserPW.Text}");
}
private void btn_RoomEnter_Click(object sender, EventArgs e)
{
var requestPkt = new RoomEnterReqPacket();
requestPkt.SetValue(textBoxRoomNumber.Text.ToInt32());
PostSendPacket(PACKET_ID.ROOM_ENTER_REQ, requestPkt.ToBytes());
DevLog.Write($"방 입장 요청: {textBoxRoomNumber.Text} 번");
}
private void btn_RoomLeave_Click(object sender, EventArgs e)
{
PostSendPacket(PACKET_ID.ROOM_LEAVE_REQ, null);
DevLog.Write($"방 입장 요청: {textBoxRoomNumber.Text} 번");
}
private void btnRoomChat_Click(object sender, EventArgs e)
{
if(textBoxRoomSendMsg.Text.IsEmpty())
{
MessageBox.Show("채팅 메시지를 입력하세요");
return;
}
var requestPkt = new RoomChatReqPacket();
requestPkt.SetValue(textBoxRoomSendMsg.Text);
PostSendPacket(PACKET_ID.ROOM_CHAT_REQ, requestPkt.ToBytes());
DevLog.Write($"방 채팅 요청");
}
private void btnRoomRelay_Click(object sender, EventArgs e)
{
//if( textBoxRelay.Text.IsEmpty())
//{
// MessageBox.Show("릴레이 할 데이터가 없습니다");
// return;
//}
//var bodyData = Encoding.UTF8.GetBytes(textBoxRelay.Text);
//PostSendPacket(PACKET_ID.PACKET_ID_ROOM_RELAY_REQ, bodyData);
//DevLog.Write($"방 릴레이 요청");
}
// 로그인서버에 로그인 요청하기
private async void button3_Click(object sender, EventArgs e)
{
var client = new HttpClient();
var loginJson = new LoginReqJson { userID = textBox2.Text, userPW = "hhh" };
var json = Utf8Json.JsonSerializer.ToJsonString(loginJson);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(textBox1.Text, content);
var responseStream = await response.Content.ReadAsByteArrayAsync();//await response.Content.ReadAsStringAsync();
var loginRes = Utf8Json.JsonSerializer.Deserialize<LoginResJson>(responseStream);
if (loginRes.result == 1)
{
textBoxIP.Text = loginRes.gameServerIP;
textBoxPort.Text = loginRes.gameServerPort.ToString();
textBoxUserID.Text = textBox2.Text;
textBoxUserPW.Text = loginRes.authToken;
DevLog.Write($"[성공] LoginServer에 로그인 요청");
}
else
{
DevLog.Write($"[실패] LoginServer에 로그인 요청 !!!");
}
}
}
}
| cpp/Demo_2020-02-15/Client/mainForm.cs | jacking75-how_to_use_redis_lib-d3accba | [
{
"filename": "cpp/Demo_2020-02-15/Client/PacketProcessForm.cs",
"retrieved_chunk": " DevLog.Write($\"방의 기존 유저 리스트 받음\");\n }\n void PacketProcess_RoomNewUserNotify(byte[] bodyData)\n {\n var notifyPkt = new RoomNewUserNtfPacket();\n notifyPkt.FromBytes(bodyData);\n AddRoomUserList(notifyPkt.UserUniqueId, notifyPkt.UserID);\n DevLog.Write($\"방에 새로 들어온 유저 받음\");\n }\n void PacketProcess_RoomLeaveResponse(byte[] bodyData)",
"score": 0.8451990485191345
},
{
"filename": "cpp/Demo_2020-02-15/Client/ClientSimpleTcp.cs",
"retrieved_chunk": " return Tuple.Create(nRecv,ReadBuffer);\n }\n catch (SocketException se)\n {\n LatestErrorMsg = se.Message;\n }\n return null;\n }\n //스트림에 쓰기\n public void Send(byte[] sendData)",
"score": 0.8299903869628906
},
{
"filename": "cpp/Demo_2020-02-15/Client/PacketProcessForm.cs",
"retrieved_chunk": " responsePkt.FromBytes(bodyData);\n AddRoomChatMessageList(responsePkt.UserID, responsePkt.Message);\n }\n void AddRoomChatMessageList(string userID, string msgssage)\n {\n var msg = $\"{userID}: {msgssage}\";\n if (listBoxRoomChatMsg.Items.Count > 512)\n {\n listBoxRoomChatMsg.Items.Clear();\n }",
"score": 0.8260467052459717
},
{
"filename": "cpp/Demo_2020-02-15/Client/PacketProcessForm.cs",
"retrieved_chunk": " DevLog.Write(msg, LOG_LEVEL.ERROR);\n }\n else\n {\n AddRoomChatMessageList(\"\", msg);\n }\n }\n void PacketProcess_RoomChatNotify(byte[] bodyData)\n {\n var responsePkt = new RoomChatNtfPacket();",
"score": 0.8255966305732727
},
{
"filename": "cpp/Demo_2020-02-15/Client/PacketProcessForm.cs",
"retrieved_chunk": " listBoxRoomChatMsg.Items.Add(msg);\n listBoxRoomChatMsg.SelectedIndex = listBoxRoomChatMsg.Items.Count - 1;\n }\n void PacketProcess_RoomRelayNotify(byte[] bodyData)\n {\n var notifyPkt = new RoomRelayNtfPacket();\n notifyPkt.FromBytes(bodyData);\n var stringData = Encoding.UTF8.GetString(notifyPkt.RelayData);\n DevLog.Write($\"방에서 릴레이 받음. {notifyPkt.UserUniqueId} - {stringData}\");\n }",
"score": 0.8184103965759277
}
] | csharp | PACKET_ID packetID, byte[] bodyData)
{ |
using HarmonyLib;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using UnityEngine;
namespace Ultrapain.Patches
{
public class OrbitalStrikeFlag : MonoBehaviour
{
public CoinChainList chainList;
public bool isOrbitalRay = false;
public bool exploded = false;
public float activasionDistance;
}
public class Coin_Start
{
static void Postfix(Coin __instance)
{
__instance.gameObject.AddComponent<OrbitalStrikeFlag>();
}
}
public class CoinChainList : MonoBehaviour
{
public List<Coin> chainList = new List<Coin>();
public bool isOrbitalStrike = false;
public float activasionDistance;
}
class Punch_BlastCheck
{
[HarmonyBefore(new string[] { "tempy.fastpunch" })]
static bool Prefix(Punch __instance)
{
__instance.blastWave = GameObject.Instantiate(Plugin.explosionWaveKnuckleblaster, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.blastWave.AddComponent<OrbitalStrikeFlag>();
return true;
}
[HarmonyBefore(new string[] { "tempy.fastpunch" })]
static void Postfix(Punch __instance)
{
GameObject.Destroy(__instance.blastWave);
__instance.blastWave = Plugin.explosionWaveKnuckleblaster;
}
}
class Explosion_Collide
{
static bool Prefix(Explosion __instance, Collider __0, List<Collider> ___hitColliders)
{
if (___hitColliders.Contains(__0)/* || __instance.transform.parent.GetComponent<OrbitalStrikeFlag>() == null*/)
return true;
Coin coin = __0.GetComponent<Coin>();
if (coin != null)
{
OrbitalStrikeFlag flag = coin.GetComponent<OrbitalStrikeFlag>();
if(flag == null)
{
coin.gameObject.AddComponent<OrbitalStrikeFlag>();
Debug.Log("Added orbital strike flag");
}
}
return true;
}
}
class Coin_DelayedReflectRevolver
{
static void Postfix(Coin __instance, GameObject ___altBeam)
{
CoinChainList flag = null;
OrbitalStrikeFlag orbitalBeamFlag = null;
if (___altBeam != null)
{
orbitalBeamFlag = ___altBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalBeamFlag == null)
{
orbitalBeamFlag = ___altBeam.AddComponent<OrbitalStrikeFlag>();
GameObject obj = new GameObject();
obj.AddComponent<RemoveOnTime>().time = 5f;
flag = obj.AddComponent<CoinChainList>();
orbitalBeamFlag.chainList = flag;
}
else
flag = orbitalBeamFlag.chainList;
}
else
{
if (__instance.ccc == null)
{
GameObject obj = new GameObject();
__instance.ccc = obj.AddComponent<CoinChainCache>();
obj.AddComponent<RemoveOnTime>().time = 5f;
}
flag = __instance.ccc.gameObject.GetComponent<CoinChainList>();
if(flag == null)
flag = __instance.ccc.gameObject.AddComponent<CoinChainList>();
}
if (flag == null)
return;
if (!flag.isOrbitalStrike && flag.chainList.Count != 0 && __instance.GetComponent<OrbitalStrikeFlag>() != null)
{
Coin lastCoin = flag.chainList.LastOrDefault();
float distance = Vector3.Distance(__instance.transform.position, lastCoin.transform.position);
if (distance >= ConfigManager.orbStrikeMinDistance.value)
{
flag.isOrbitalStrike = true;
flag.activasionDistance = distance;
if (orbitalBeamFlag != null)
{
orbitalBeamFlag.isOrbitalRay = true;
orbitalBeamFlag.activasionDistance = distance;
}
Debug.Log("Coin valid for orbital strike");
}
}
if (flag.chainList.Count == 0 || flag.chainList.LastOrDefault() != __instance)
flag.chainList.Add(__instance);
}
}
class Coin_ReflectRevolver
{
public static bool coinIsShooting = false;
public static Coin shootingCoin = null;
public static GameObject shootingAltBeam;
public static float lastCoinTime = 0;
static bool Prefix(Coin __instance, GameObject ___altBeam)
{
coinIsShooting = true;
shootingCoin = __instance;
lastCoinTime = Time.time;
shootingAltBeam = ___altBeam;
return true;
}
static void Postfix(Coin __instance)
{
coinIsShooting = false;
}
}
class RevolverBeam_Start
{
static bool Prefix(RevolverBeam __instance)
{
OrbitalStrikeFlag flag = __instance.GetComponent<OrbitalStrikeFlag>();
if (flag != null && flag.isOrbitalRay)
{
RevolverBeam_ExecuteHits.orbitalBeam = __instance;
RevolverBeam_ExecuteHits.orbitalBeamFlag = flag;
}
return true;
}
}
class RevolverBeam_ExecuteHits
{
public static bool isOrbitalRay = false;
public static RevolverBeam orbitalBeam = null;
public static OrbitalStrikeFlag orbitalBeamFlag = null;
static bool Prefix(RevolverBeam __instance)
{
OrbitalStrikeFlag flag = __instance.GetComponent<OrbitalStrikeFlag>();
if (flag != null && flag.isOrbitalRay)
{
isOrbitalRay = true;
orbitalBeam = __instance;
orbitalBeamFlag = flag;
}
return true;
}
static void Postfix()
{
isOrbitalRay = false;
}
}
class OrbitalExplosionInfo : MonoBehaviour
{
public bool active = true;
public string id;
public int points;
}
class Grenade_Explode
{
class StateInfo
{
public bool state = false;
public string id;
public int points;
public | GameObject templateExplosion; |
}
static bool Prefix(Grenade __instance, ref float __3, out StateInfo __state,
bool __1, bool __2)
{
__state = new StateInfo();
if((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null) || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f))
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike)
{
if (__1)
{
__state.templateExplosion = GameObject.Instantiate(__instance.harmlessExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.harmlessExplosion = __state.templateExplosion;
}
else if (__2)
{
__state.templateExplosion = GameObject.Instantiate(__instance.superExplosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.superExplosion = __state.templateExplosion;
}
else
{
__state.templateExplosion = GameObject.Instantiate(__instance.explosion, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
__instance.explosion = __state.templateExplosion;
}
OrbitalExplosionInfo info = __state.templateExplosion.AddComponent<OrbitalExplosionInfo>();
info.id = "";
__state.state = true;
float damageMulti = 1f;
float sizeMulti = 1f;
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if (ConfigManager.orbStrikeRevolverChargedGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverChargedStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverChargedStylePoint.value;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if (ConfigManager.orbStrikeElectricCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeElectricCannonExplosionDamage.value;
sizeMulti += ConfigManager.orbStrikeElectricCannonExplosionSize.value;
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
if (ConfigManager.orbStrikeMaliciousCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
}
}
else
__state.state = false;
}
else
__state.state = false;
if(sizeMulti != 1 || damageMulti != 1)
foreach(Explosion exp in __state.templateExplosion.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.damage = (int)(exp.damage * damageMulti);
}
Debug.Log("Applied orbital strike bonus");
}
}
return true;
}
static void Postfix(Grenade __instance, StateInfo __state)
{
if (__state.templateExplosion != null)
GameObject.Destroy(__state.templateExplosion);
if (!__state.state)
return;
}
}
class Cannonball_Explode
{
static bool Prefix(Cannonball __instance, GameObject ___interruptionExplosion, ref GameObject ___breakEffect)
{
if ((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null) || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f))
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike && ___interruptionExplosion != null)
{
float damageMulti = 1f;
float sizeMulti = 1f;
GameObject explosion = GameObject.Instantiate<GameObject>(___interruptionExplosion, __instance.transform.position, Quaternion.identity);
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = "";
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if (ConfigManager.orbStrikeRevolverChargedGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverChargedGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverChargedStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverChargedStylePoint.value;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverGrenade.value)
{
damageMulti += ConfigManager.orbStrikeRevolverGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeRevolverGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if (ConfigManager.orbStrikeElectricCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeElectricCannonExplosionDamage.value;
sizeMulti += ConfigManager.orbStrikeElectricCannonExplosionSize.value;
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
if (ConfigManager.orbStrikeMaliciousCannonGrenade.value)
{
damageMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraDamage.value;
sizeMulti += ConfigManager.orbStrikeMaliciousCannonGrenadeExtraSize.value;
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
}
}
}
if (sizeMulti != 1 || damageMulti != 1)
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.damage = (int)(exp.damage * damageMulti);
}
if (MonoSingleton<PrefsManager>.Instance.GetBoolLocal("simpleExplosions", false))
{
___breakEffect = null;
}
__instance.Break();
return false;
}
}
return true;
}
}
class Explosion_CollideOrbital
{
static bool Prefix(Explosion __instance, Collider __0)
{
OrbitalExplosionInfo flag = __instance.transform.parent.GetComponent<OrbitalExplosionInfo>();
if (flag == null || !flag.active)
return true;
if ( __0.gameObject.tag != "Player" && (__0.gameObject.layer == 10 || __0.gameObject.layer == 11)
&& __instance.canHit != AffectedSubjects.PlayerOnly)
{
EnemyIdentifierIdentifier componentInParent = __0.GetComponentInParent<EnemyIdentifierIdentifier>();
if (componentInParent != null && componentInParent.eid != null && !componentInParent.eid.blessed/* && !componentInParent.eid.dead*/)
{
flag.active = false;
if(flag.id != "")
StyleHUD.Instance.AddPoints(flag.points, flag.id);
}
}
return true;
}
}
class EnemyIdentifier_DeliverDamage
{
static Coin lastExplosiveCoin = null;
class StateInfo
{
public bool canPostStyle = false;
public OrbitalExplosionInfo info = null;
}
static bool Prefix(EnemyIdentifier __instance, out StateInfo __state, Vector3 __2, ref float __3)
{
//if (Coin_ReflectRevolver.shootingCoin == lastExplosiveCoin)
// return true;
__state = new StateInfo();
bool causeExplosion = false;
if (__instance.dead)
return true;
if ((Coin_ReflectRevolver.coinIsShooting && Coin_ReflectRevolver.shootingCoin != null)/* || (Time.time - Coin_ReflectRevolver.lastCoinTime <= 0.1f)*/)
{
CoinChainList list = null;
if (Coin_ReflectRevolver.shootingAltBeam != null)
{
OrbitalStrikeFlag orbitalFlag = Coin_ReflectRevolver.shootingAltBeam.GetComponent<OrbitalStrikeFlag>();
if (orbitalFlag != null)
list = orbitalFlag.chainList;
}
else if (Coin_ReflectRevolver.shootingCoin != null && Coin_ReflectRevolver.shootingCoin.ccc != null)
list = Coin_ReflectRevolver.shootingCoin.ccc.GetComponent<CoinChainList>();
if (list != null && list.isOrbitalStrike)
{
causeExplosion = true;
}
}
else if (RevolverBeam_ExecuteHits.isOrbitalRay && RevolverBeam_ExecuteHits.orbitalBeam != null)
{
if (RevolverBeam_ExecuteHits.orbitalBeamFlag != null && !RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded)
{
causeExplosion = true;
}
}
if(causeExplosion)
{
__state.canPostStyle = true;
// REVOLVER NORMAL
if (Coin_ReflectRevolver.shootingAltBeam == null)
{
if(ConfigManager.orbStrikeRevolverExplosion.value)
{
GameObject explosion = GameObject.Instantiate(Plugin.explosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeRevolverExplosionDamage.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
__state.info = info;
}
}
else if (Coin_ReflectRevolver.shootingAltBeam.TryGetComponent(out RevolverBeam beam))
{
if (beam.beamType == BeamType.Revolver)
{
// REVOLVER CHARGED (NORMAL + ALT. IF DISTINCTION IS NEEDED, USE beam.strongAlt FOR ALT)
if (beam.ultraRicocheter)
{
if(ConfigManager.orbStrikeRevolverChargedInsignia.value)
{
GameObject insignia = GameObject.Instantiate(Plugin.virtueInsignia, /*__instance.transform.position*/__2, Quaternion.identity);
// This is required for ff override to detect this insignia as non ff attack
insignia.gameObject.name = "PlayerSpawned";
float horizontalSize = ConfigManager.orbStrikeRevolverChargedInsigniaSize.value;
insignia.transform.localScale = new Vector3(horizontalSize, insignia.transform.localScale.y, horizontalSize);
VirtueInsignia comp = insignia.GetComponent<VirtueInsignia>();
comp.windUpSpeedMultiplier = ConfigManager.orbStrikeRevolverChargedInsigniaDelayBoost.value;
comp.damage = ConfigManager.orbStrikeRevolverChargedInsigniaDamage.value;
comp.predictive = false;
comp.hadParent = false;
comp.noTracking = true;
StyleHUD.Instance.AddPoints(ConfigManager.orbStrikeRevolverChargedStylePoint.value, ConfigManager.orbStrikeRevolverChargedStyleText.guid);
__state.canPostStyle = false;
}
}
// REVOLVER ALT
else
{
if (ConfigManager.orbStrikeRevolverExplosion.value)
{
GameObject explosion = GameObject.Instantiate(Plugin.explosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeRevolverExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeRevolverExplosionDamage.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeRevolverStyleText.guid;
info.points = ConfigManager.orbStrikeRevolverStylePoint.value;
__state.info = info;
}
}
}
// ELECTRIC RAILCANNON
else if (beam.beamType == BeamType.Railgun && beam.hitAmount > 500)
{
if(ConfigManager.orbStrikeElectricCannonExplosion.value)
{
GameObject lighning = GameObject.Instantiate(Plugin.lightningStrikeExplosive, /*__instance.gameObject.transform.position*/ __2, Quaternion.identity);
foreach (Explosion exp in lighning.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
if (exp.damage == 0)
exp.maxSize /= 2;
exp.maxSize *= ConfigManager.orbStrikeElectricCannonExplosionSize.value;
exp.speed *= ConfigManager.orbStrikeElectricCannonExplosionSize.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeElectricCannonExplosionDamage.value);
exp.canHit = AffectedSubjects.All;
}
OrbitalExplosionInfo info = lighning.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeElectricCannonStyleText.guid;
info.points = ConfigManager.orbStrikeElectricCannonStylePoint.value;
__state.info = info;
}
}
// MALICIOUS RAILCANNON
else if (beam.beamType == BeamType.Railgun)
{
// UNUSED
causeExplosion = false;
}
// MALICIOUS BEAM
else if (beam.beamType == BeamType.MaliciousFace)
{
GameObject explosion = GameObject.Instantiate(Plugin.sisyphiusPrimeExplosion, /*__instance.gameObject.transform.position*/__2, Quaternion.identity);
foreach (Explosion exp in explosion.GetComponentsInChildren<Explosion>())
{
exp.enemy = false;
exp.hitterWeapon = "";
exp.maxSize *= ConfigManager.maliciousChargebackExplosionSizeMultiplier.value;
exp.speed *= ConfigManager.maliciousChargebackExplosionSizeMultiplier.value;
exp.damage = (int)(exp.damage * ConfigManager.maliciousChargebackExplosionDamageMultiplier.value);
}
OrbitalExplosionInfo info = explosion.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.maliciousChargebackStyleText.guid;
info.points = ConfigManager.maliciousChargebackStylePoint.value;
__state.info = info;
}
// SENTRY BEAM
else if (beam.beamType == BeamType.Enemy)
{
StyleHUD.Instance.AddPoints(ConfigManager.sentryChargebackStylePoint.value, ConfigManager.sentryChargebackStyleText.formattedString);
if (ConfigManager.sentryChargebackExtraBeamCount.value > 0)
{
List<Tuple<EnemyIdentifier, float>> enemies = UnityUtils.GetClosestEnemies(__2, ConfigManager.sentryChargebackExtraBeamCount.value, UnityUtils.doNotCollideWithPlayerValidator);
foreach (Tuple<EnemyIdentifier, float> enemy in enemies)
{
RevolverBeam newBeam = GameObject.Instantiate(beam, beam.transform.position, Quaternion.identity);
newBeam.hitEids.Add(__instance);
newBeam.transform.LookAt(enemy.Item1.transform);
GameObject.Destroy(newBeam.GetComponent<OrbitalStrikeFlag>());
}
}
RevolverBeam_ExecuteHits.isOrbitalRay = false;
}
}
if (causeExplosion && RevolverBeam_ExecuteHits.orbitalBeamFlag != null)
RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded = true;
Debug.Log("Applied orbital strike explosion");
}
return true;
}
static void Postfix(EnemyIdentifier __instance, StateInfo __state)
{
if(__state.canPostStyle && __instance.dead && __state.info != null)
{
__state.info.active = false;
if (__state.info.id != "")
StyleHUD.Instance.AddPoints(__state.info.points, __state.info.id);
}
}
}
class RevolverBeam_HitSomething
{
static bool Prefix(RevolverBeam __instance, out GameObject __state)
{
__state = null;
if (RevolverBeam_ExecuteHits.orbitalBeam == null)
return true;
if (__instance.beamType != BeamType.Railgun)
return true;
if (__instance.hitAmount != 1)
return true;
if (RevolverBeam_ExecuteHits.orbitalBeam.GetInstanceID() == __instance.GetInstanceID())
{
if (!RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded && ConfigManager.orbStrikeMaliciousCannonExplosion.value)
{
Debug.Log("MALICIOUS EXPLOSION EXTRA SIZE");
GameObject tempExp = GameObject.Instantiate(__instance.hitParticle, new Vector3(1000000, 1000000, 1000000), Quaternion.identity);
foreach (Explosion exp in tempExp.GetComponentsInChildren<Explosion>())
{
exp.maxSize *= ConfigManager.orbStrikeMaliciousCannonExplosionSizeMultiplier.value;
exp.speed *= ConfigManager.orbStrikeMaliciousCannonExplosionSizeMultiplier.value;
exp.damage = (int)(exp.damage * ConfigManager.orbStrikeMaliciousCannonExplosionDamageMultiplier.value);
}
__instance.hitParticle = tempExp;
OrbitalExplosionInfo info = tempExp.AddComponent<OrbitalExplosionInfo>();
info.id = ConfigManager.orbStrikeMaliciousCannonStyleText.guid;
info.points = ConfigManager.orbStrikeMaliciousCannonStylePoint.value;
RevolverBeam_ExecuteHits.orbitalBeamFlag.exploded = true;
}
Debug.Log("Already exploded");
}
else
Debug.Log("Not the same instance");
return true;
}
static void Postfix(RevolverBeam __instance, GameObject __state)
{
if (__state != null)
GameObject.Destroy(__state);
}
}
}
| Ultrapain/Patches/OrbitalStrike.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/V2Common.cs",
"retrieved_chunk": " return true;\n }\n }\n class V2CommonRevolverBulletSharp : MonoBehaviour\n {\n public int reflectionCount = 2;\n public float autoAimAngle = 30f;\n public Projectile proj;\n public float speed = 350f;\n public bool hasTargetPoint = false;",
"score": 0.882635235786438
},
{
"filename": "Ultrapain/Patches/CommonComponents.cs",
"retrieved_chunk": " public Quaternion targetRotation;\n private void Awake()\n {\n transform.rotation = targetRotation;\n }\n }\n public class CommonActivator : MonoBehaviour\n {\n public int originalId;\n public Renderer rend;",
"score": 0.8794397115707397
},
{
"filename": "Ultrapain/Patches/Parry.cs",
"retrieved_chunk": "using HarmonyLib;\nusing UnityEngine;\nnamespace Ultrapain.Patches\n{\n class GrenadeParriedFlag : MonoBehaviour\n {\n public int parryCount = 1;\n public bool registeredStyle = false;\n public bool bigExplosionOverride = false;\n public GameObject temporaryExplosion;",
"score": 0.8736869692802429
},
{
"filename": "Ultrapain/Patches/Parry.cs",
"retrieved_chunk": " public GameObject temporaryBigExplosion;\n public GameObject weapon;\n public enum GrenadeType\n {\n Core,\n Rocket,\n }\n public GrenadeType grenadeType;\n }\n class Punch_CheckForProjectile_Patch",
"score": 0.8689522743225098
},
{
"filename": "Ultrapain/Patches/CommonComponents.cs",
"retrieved_chunk": " public float superSize = 1f;\n public float superSpeed = 1f;\n public float superDamage = 1f;\n public int superPlayerDamageOverride = -1;\n struct StateInfo\n {\n public GameObject tempHarmless;\n public GameObject tempNormal;\n public GameObject tempSuper;\n public StateInfo()",
"score": 0.8677950501441956
}
] | csharp | GameObject templateExplosion; |
using ECS.ComponentsAndTags;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;
namespace ECS.Systems
{
/// <summary>
/// After AssignTargetSystems starts working this systems move units to their targets.
/// </summary>
[UpdateAfter(typeof(ECS.Systems. | AssignTargetSystem))]
public partial class MovementSystem : SystemBase
{ |
EndSimulationEntityCommandBufferSystem _endSimulationEcbSystem;
protected override void OnCreate()
{
base.OnCreate();
Enabled = false;
_endSimulationEcbSystem = World.GetOrCreateSystem<EndSimulationEntityCommandBufferSystem>();
GameManager.GameStarted += OnGameStarted;
GameManager.GameReloaded += OnGameReloaded;
}
private void OnGameReloaded()
{
Enabled = false;
}
private void OnGameStarted()
{
Enabled = true;
}
protected override void OnUpdate()
{
var ecb = _endSimulationEcbSystem.CreateCommandBuffer().AsParallelWriter();
float deltaTime = Time.DeltaTime;
var entities = EntityManager.GetAllEntities(Allocator.TempJob);
Entities
.ForEach((Entity entity, int entityInQueryIndex, in Translation position, in MovementSpeedComponent movementSpeed, in TargetComponent target, in AttackRangeComponent attackRange) =>
{
//Check if entity exist, different way to check if target entity is valid
if (!entities.Contains(target.value) || !HasComponent<Translation>(target.value))
{
return;
}
//Check target units distance, if close stop
float3 targetPosition = GetComponent<Translation>(target.value).Value;
targetPosition.y = position.Value.y;
if (math.distance(targetPosition, position.Value) <= attackRange.value)
{
return;
}
// If target unit is not in range, move to target
float3 direction = math.normalize(targetPosition - position.Value);
ecb.SetComponent(entityInQueryIndex, entity, new Translation()
{
Value = position.Value + direction * movementSpeed.value * deltaTime
});
}).ScheduleParallel();
_endSimulationEcbSystem.AddJobHandleForProducer(Dependency);
}
}
} | Assets/Scripts/ECS/Systems/MovementSystem.cs | aknkrstozkn-BattleSimulator-DOTS-48e9e68 | [
{
"filename": "Assets/Scripts/ECS/Systems/DeathSystem.cs",
"retrieved_chunk": "using ECS.ComponentsAndTags;\nusing Unity.Entities;\nnamespace ECS.Systems\n{\n\t/// <summary>\n\t/// This systems checks if an entities hp below or equal zero to destroy it.\n\t/// </summary>\n\t[UpdateAfter(typeof(ECS.Systems.AttackSystem))]\n\tpublic partial class DeathSystem : SystemBase\n\t{",
"score": 0.8657435178756714
},
{
"filename": "Assets/Scripts/ECS/Systems/UpdateHealthDisplaySystem.cs",
"retrieved_chunk": "using ECS.ComponentsAndTags;\nusing Unity.Entities;\nusing UnityEngine;\nnamespace ECS.Systems\n{\n\t/// <summary>\n\t/// Updated health texts of units\n\t/// </summary>\n\t[UpdateAfter(typeof(InitializeUnitsSystem))]\n\tpublic partial class UpdateHealthDisplaySystem : SystemBase",
"score": 0.8493282794952393
},
{
"filename": "Assets/Scripts/ECS/Systems/AttackSystem.cs",
"retrieved_chunk": "using ECS.ComponentsAndTags;\nusing Unity.Entities;\nusing Unity.Mathematics;\nusing Unity.Transforms;\nnamespace ECS.Systems\n{\n\t/// <summary>\n\t/// This systems handles units attacks\n\t/// </summary>\n\t[UpdateAfter(typeof(MovementSystem))]",
"score": 0.8123754262924194
},
{
"filename": "Assets/Scripts/ECS/ComponentsAndTags/TargetComponent.cs",
"retrieved_chunk": "using System;\nusing Unity.Entities;\nnamespace ECS.ComponentsAndTags\n{\n\t/// <summary>\n\t/// Unit component to hold target entity\n\t/// </summary>\n\t[Serializable]\n\tpublic struct TargetComponent : IComponentData\n\t{",
"score": 0.8114608526229858
},
{
"filename": "Assets/Scripts/ECS/ComponentsAndTags/AttackCooldownComponent.cs",
"retrieved_chunk": "using System;\nusing Unity.Entities;\nnamespace ECS.ComponentsAndTags\n{\n\t/// <summary>\n\t/// Controls delay of the attacks \n\t/// </summary>\n\t[Serializable]\n\tpublic struct AttackCooldownComponent : IComponentData\n\t{",
"score": 0.7948619723320007
}
] | csharp | AssignTargetSystem))]
public partial class MovementSystem : SystemBase
{ |
#nullable enable
using System.Collections.Generic;
using Mochineko.Relent.Result;
namespace Mochineko.RelentStateMachine
{
internal sealed class TransitionMap<TEvent, TContext>
: | ITransitionMap<TEvent, TContext>
{ |
private readonly IState<TEvent, TContext> initialState;
private readonly IReadOnlyList<IState<TEvent, TContext>> states;
private readonly IReadOnlyDictionary<
IState<TEvent, TContext>,
IReadOnlyDictionary<TEvent, IState<TEvent, TContext>>>
transitionMap;
private readonly IReadOnlyDictionary<TEvent, IState<TEvent, TContext>>
anyTransitionMap;
public TransitionMap(
IState<TEvent, TContext> initialState,
IReadOnlyList<IState<TEvent, TContext>> states,
IReadOnlyDictionary<
IState<TEvent, TContext>,
IReadOnlyDictionary<TEvent, IState<TEvent, TContext>>>
transitionMap,
IReadOnlyDictionary<TEvent, IState<TEvent, TContext>> anyTransitionMap)
{
this.initialState = initialState;
this.states = states;
this.transitionMap = transitionMap;
this.anyTransitionMap = anyTransitionMap;
}
IState<TEvent, TContext> ITransitionMap<TEvent, TContext>.InitialState
=> initialState;
IResult<IState<TEvent, TContext>> ITransitionMap<TEvent, TContext>.AllowedToTransit(
IState<TEvent, TContext> currentState,
TEvent @event)
{
if (transitionMap.TryGetValue(currentState, out var candidates))
{
if (candidates.TryGetValue(@event, out var nextState))
{
return Results.Succeed(nextState);
}
}
if (anyTransitionMap.TryGetValue(@event, out var nextStateFromAny))
{
return Results.Succeed(nextStateFromAny);
}
return Results.Fail<IState<TEvent, TContext>>(
$"Not found transition from {currentState.GetType()} with event {@event}.");
}
public void Dispose()
{
foreach (var state in states)
{
state.Dispose();
}
}
}
} | Assets/Mochineko/RelentStateMachine/TransitionMap.cs | mochi-neko-RelentStateMachine-64762eb | [
{
"filename": "Assets/Mochineko/RelentStateMachine/FiniteStateMachine.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Threading;\nusing Cysharp.Threading.Tasks;\nusing Mochineko.Relent.Result;\nnamespace Mochineko.RelentStateMachine\n{\n public sealed class FiniteStateMachine<TEvent, TContext>\n : IFiniteStateMachine<TEvent, TContext>\n {",
"score": 0.9086297154426575
},
{
"filename": "Assets/Mochineko/RelentStateMachine/StackStateMachine.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nusing System.Threading;\nusing Cysharp.Threading.Tasks;\nusing Mochineko.Relent.Result;\nnamespace Mochineko.RelentStateMachine\n{\n public sealed class StackStateMachine<TContext>\n : IStackStateMachine<TContext>",
"score": 0.8941016793251038
},
{
"filename": "Assets/Mochineko/RelentStateMachine/TransitionMapBuilder.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nnamespace Mochineko.RelentStateMachine\n{\n public sealed class TransitionMapBuilder<TEvent, TContext>\n : ITransitionMapBuilder<TEvent, TContext>\n {\n private readonly IState<TEvent, TContext> initialState;\n private readonly List<IState<TEvent, TContext>> states = new();",
"score": 0.8834070563316345
},
{
"filename": "Assets/Mochineko/RelentStateMachine.Tests/Phase4State.cs",
"retrieved_chunk": "#nullable enable\nusing System.Threading;\nusing Cysharp.Threading.Tasks;\nusing Mochineko.Relent.Result;\n#pragma warning disable CS1998\nnamespace Mochineko.RelentStateMachine.Tests\n{\n internal sealed class Phase4State : IState<MockContinueEvent, MockContinueContext>\n {\n public async UniTask<IEventRequest<MockContinueEvent>> EnterAsync(",
"score": 0.873934268951416
},
{
"filename": "Assets/Mochineko/RelentStateMachine/ITransitionMap.cs",
"retrieved_chunk": "#nullable enable\nusing System;\nusing Mochineko.Relent.Result;\nnamespace Mochineko.RelentStateMachine\n{\n public interface ITransitionMap<TEvent, TContext> : IDisposable\n {\n internal IState<TEvent, TContext> InitialState { get; }\n internal IResult<IState<TEvent, TContext>> AllowedToTransit(IState<TEvent, TContext> currentState, TEvent @event);\n }",
"score": 0.8652472496032715
}
] | csharp | ITransitionMap<TEvent, TContext>
{ |
// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
#nullable disable
using System;
using System.Collections.Generic;
using osu.Framework.Allocation;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Textures;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input.Bindings;
using osu.Framework.Input.Events;
using osu.Framework.Logging;
using osu.Framework.Screens;
using osu.Game.Audio;
using osu.Game.Screens;
using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Gengo.UI.Translation;
using osu.Game.Rulesets.Gengo.Anki;
using osu.Game.Rulesets.Gengo.Cards;
using osuTK;
using osuTK.Graphics;
namespace osu.Game.Rulesets.Gengo.Objects.Drawables
{
public partial class DrawableGengoHitObject : DrawableHitObject< | GengoHitObject>, IKeyBindingHandler<GengoAction>
{ |
private const double time_preempt = 600;
private const double time_fadein = 400;
public override bool HandlePositionalInput => true;
public DrawableGengoHitObject(GengoHitObject hitObject)
: base(hitObject)
{
Size = new Vector2(80);
Origin = Anchor.Centre;
Position = hitObject.Position;
}
[Resolved]
protected TranslationContainer translationContainer { get; set; }
[Resolved]
protected AnkiAPI anki { get; set; }
private Card assignedCard;
private Card baitCard;
private Box cardDesign;
private OsuSpriteText cardText;
[BackgroundDependencyLoader]
private void load(TextureStore textures)
{
assignedCard = anki.FetchRandomCard();
baitCard = anki.FetchRandomCard();
translationContainer.AddCard(assignedCard, baitCard);
AddInternal(new CircularContainer {
AutoSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Masking = true,
CornerRadius = 15f,
Children = new Drawable[] {
cardDesign = new Box {
RelativeSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Colour = Color4.Black,
},
cardText = new OsuSpriteText {
Text = assignedCard.foreignText,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Colour = Color4.Red,
Font = new FontUsage(size: 35f),
Margin = new MarginPadding(8f),
}
}
});
}
public override IEnumerable<HitSampleInfo> GetSamples() => new[]
{
new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
};
protected void ApplyResult(HitResult result) {
void resultApplication(JudgementResult r) => r.Type = result;
ApplyResult(resultApplication);
}
GengoAction pressedAction;
/// <summary>
/// Checks whether or not the pressed button/action for the current HitObject was correct for (matching to) the assigned card.
/// </summary>
bool CorrectActionCheck() {
if (pressedAction == GengoAction.LeftButton)
return translationContainer.leftWordText.Text == assignedCard.translatedText;
else if (pressedAction == GengoAction.RightButton)
return translationContainer.rightWordText.Text == assignedCard.translatedText;
return false;
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (!userTriggered)
{
if (!HitObject.HitWindows.CanBeHit(timeOffset)) {
translationContainer.RemoveCard();
ApplyResult(r => r.Type = r.Judgement.MinResult);
}
return;
}
var result = HitObject.HitWindows.ResultFor(timeOffset);
if (result == HitResult.None)
return;
if (!CorrectActionCheck()) {
translationContainer.RemoveCard();
ApplyResult(HitResult.Miss);
return;
}
translationContainer.RemoveCard();
ApplyResult(r => r.Type = result);
}
protected override double InitialLifetimeOffset => time_preempt;
protected override void UpdateHitStateTransforms(ArmedState state)
{
switch (state)
{
case ArmedState.Hit:
cardText.FadeColour(Color4.White, 200, Easing.OutQuint);
cardDesign.FadeColour(Color4.YellowGreen, 200, Easing.OutQuint);
this.ScaleTo(2, 500, Easing.OutQuint).Expire();
break;
default:
this.ScaleTo(0.8f, 200, Easing.OutQuint);
cardText.FadeColour(Color4.Black, 200, Easing.OutQuint);
cardDesign.FadeColour(Color4.Red, 200, Easing.OutQuint);
this.FadeOut(500, Easing.InQuint).Expire();
break;
}
}
public bool OnPressed(KeyBindingPressEvent<GengoAction> e) {
if (e.Action != GengoAction.LeftButton && e.Action != GengoAction.RightButton)
return false;
pressedAction = e.Action;
return UpdateResult(true);
}
public void OnReleased(KeyBindingReleaseEvent<GengoAction> e) {
}
}
}
| osu.Game.Rulesets.Gengo/Objects/Drawables/DrawableGengoHitObject.cs | 0xdeadbeer-gengo-dd4f78d | [
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoPlayfield.cs",
"retrieved_chunk": "using osu.Game.Rulesets.Gengo.UI.Cursor;\nusing osu.Game.Rulesets.Gengo.UI.Translation;\nusing osu.Game.Rulesets.Gengo.Configuration;\nusing osu.Game.Rulesets.Gengo.Anki;\nusing osuTK;\nnamespace osu.Game.Rulesets.Gengo.UI\n{\n [Cached]\n public partial class GengoPlayfield : ScrollingPlayfield\n {",
"score": 0.9320319294929504
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/DrawableGengoRuleset.cs",
"retrieved_chunk": "using osu.Game.Rulesets.Gengo.Objects;\nusing osu.Game.Rulesets.Gengo.Objects.Drawables;\nusing osu.Game.Rulesets.Gengo.Replays;\nusing osu.Game.Rulesets.UI;\nusing osu.Game.Rulesets.UI.Scrolling;\nusing osu.Game.Rulesets.Gengo.Anki;\nusing osu.Game.Rulesets.Gengo.Configuration;\nnamespace osu.Game.Rulesets.Gengo.UI\n{\n [Cached]",
"score": 0.8951430320739746
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoSettingsSubsection.cs",
"retrieved_chunk": "using osu.Framework.Allocation;\nusing osu.Framework.Localisation;\nusing osu.Framework.Graphics;\nusing osu.Game.Overlays.Settings;\nusing osu.Game.Rulesets.Gengo.Configuration;\nusing osu.Game.Rulesets.UI;\nnamespace osu.Game.Rulesets.Gengo.UI \n{\n public partial class GengoSettingsSubsection : RulesetSettingsSubsection {\n protected override LocalisableString Header => \"osu!gengo\";",
"score": 0.8760412931442261
},
{
"filename": "osu.Game.Rulesets.Gengo/Anki/Anki.cs",
"retrieved_chunk": "using osu.Game.Overlays;\nusing osu.Game.Screens.Play;\nusing osu.Game.Rulesets.Gengo.Cards;\nusing osu.Game.Rulesets.Gengo.Configuration;\nusing osu.Game.Rulesets.Gengo.UI;\nusing Newtonsoft.Json;\nusing Microsoft.CSharp.RuntimeBinder;\nnamespace osu.Game.Rulesets.Gengo.Anki \n{\n /// <summary>",
"score": 0.872331976890564
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/Translation/TranslationContainer.cs",
"retrieved_chunk": "using osu.Game.Beatmaps;\nusing osu.Game.Rulesets.Gengo.Cards;\nusing osu.Game.Graphics.Sprites;\nusing osuTK.Graphics;\nnamespace osu.Game.Rulesets.Gengo.UI.Translation \n{\n /// <summary>\n /// Container responsible for showing the two translation words\n /// </summary>\n public partial class TranslationContainer : GridContainer {",
"score": 0.8420993685722351
}
] | csharp | GengoHitObject>, IKeyBindingHandler<GengoAction>
{ |
using Wpf.Ui.Common.Interfaces;
namespace SupernoteDesktopClient.Views.Pages
{
/// <summary>
/// Interaction logic for SettingsPage.xaml
/// </summary>
public partial class SettingsPage : INavigableView<ViewModels.SettingsViewModel>
{
public ViewModels. | SettingsViewModel ViewModel
{ |
get;
}
public SettingsPage(ViewModels.SettingsViewModel viewModel)
{
ViewModel = viewModel;
InitializeComponent();
}
}
} | Views/Pages/SettingsPage.xaml.cs | nelinory-SupernoteDesktopClient-e527602 | [
{
"filename": "Views/Pages/SyncPage.xaml.cs",
"retrieved_chunk": "using Wpf.Ui.Common.Interfaces;\nnamespace SupernoteDesktopClient.Views.Pages\n{\n /// <summary>\n /// Interaction logic for SyncPage.xaml\n /// </summary>\n public partial class SyncPage : INavigableView<ViewModels.SyncViewModel>\n {\n public ViewModels.SyncViewModel ViewModel\n {",
"score": 0.9455142021179199
},
{
"filename": "Views/Pages/ExplorerPage.xaml.cs",
"retrieved_chunk": "using Wpf.Ui.Common.Interfaces;\nnamespace SupernoteDesktopClient.Views.Pages\n{\n /// <summary>\n /// Interaction logic for ExplorerPage.xaml\n /// </summary>\n public partial class ExplorerPage : INavigableView<ViewModels.ExplorerViewModel>\n {\n public ViewModels.ExplorerViewModel ViewModel\n {",
"score": 0.9400349855422974
},
{
"filename": "Views/Pages/DashboardPage.xaml.cs",
"retrieved_chunk": "using Wpf.Ui.Common.Interfaces;\nnamespace SupernoteDesktopClient.Views.Pages\n{\n /// <summary>\n /// Interaction logic for DashboardPage.xaml\n /// </summary>\n public partial class DashboardPage : INavigableView<ViewModels.DashboardViewModel>\n {\n public ViewModels.DashboardViewModel ViewModel\n {",
"score": 0.9374550580978394
},
{
"filename": "Views/Pages/AboutPage.xaml.cs",
"retrieved_chunk": "using Wpf.Ui.Common.Interfaces;\nnamespace SupernoteDesktopClient.Views.Pages\n{\n /// <summary>\n /// Interaction logic for AboutPage.xaml\n /// </summary>\n public partial class AboutPage : INavigableView<ViewModels.AboutViewModel>\n {\n public ViewModels.AboutViewModel ViewModel\n {",
"score": 0.9349795579910278
},
{
"filename": "Services/PageService.cs",
"retrieved_chunk": "using System;\nusing System.Windows;\nusing Wpf.Ui.Mvvm.Contracts;\nnamespace SupernoteDesktopClient.Services\n{\n /// <summary>\n /// Service that provides pages for navigation.\n /// </summary>\n public class PageService : IPageService\n {",
"score": 0.8845406770706177
}
] | csharp | SettingsViewModel ViewModel
{ |
using System;
using System.Runtime.Serialization;
namespace TreeifyTask
{
[Serializable]
public class TaskNodeCycleDetectedException : Exception
{
public ITaskNode NewTask { get; }
public ITaskNode ParentTask { get; }
public string MessageStr { get; private set; }
public TaskNodeCycleDetectedException()
: base("Cycle detected in the task tree.")
{
}
public TaskNodeCycleDetectedException( | ITaskNode newTask, ITaskNode parentTask)
: base($"Task '{ | newTask?.Id}' was already added as a child to task tree of '{parentTask?.Id}'.")
{
this.NewTask = newTask;
this.ParentTask = parentTask;
}
public TaskNodeCycleDetectedException(string message) : base(message)
{
}
public TaskNodeCycleDetectedException(string message, Exception innerException) : base(message, innerException)
{
}
protected TaskNodeCycleDetectedException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
} | Source/TreeifyTask/TaskTree/TaskNodeCycleDetectedException.cs | intuit-TreeifyTask-4b124d4 | [
{
"filename": "Source/TreeifyTask/TaskTree/TaskNode.cs",
"retrieved_chunk": " : this(Id)\n {\n this.SetAction(cancellableProgressReportingAsyncFunction);\n }\n #region Props\n public string Id { get; set; }\n public double ProgressValue { get; private set; }\n public object ProgressState { get; private set; }\n public TaskStatus TaskStatus { get; private set; }\n public ITaskNode Parent { get; set; }",
"score": 0.8637319803237915
},
{
"filename": "Source/TreeifyTask.BlazorSample/TaskDataModel/code.cs",
"retrieved_chunk": " Children = children;\n }\n public string Id { get; }\n public CancellableAsyncActionDelegate Action { get; }\n public AT[] Children { get; }\n }\n public class CodeTry\n {\n public void SyntaxCheck()\n {",
"score": 0.8454334139823914
},
{
"filename": "Source/TreeifyTask/TaskTree/ProgressReportingEventArgs.cs",
"retrieved_chunk": "using System;\nnamespace TreeifyTask\n{\n public class ProgressReportingEventArgs : EventArgs\n {\n public TaskStatus TaskStatus { get; set; }\n public double ProgressValue { get; set; }\n public object ProgressState { get; set; }\n public bool ChildTasksRunningInParallel { get; set; }\n }",
"score": 0.8451982736587524
},
{
"filename": "Source/TreeifyTask.BlazorSample/TaskDataModel/code.cs",
"retrieved_chunk": " {\n throw new NotImplementedException();\n }\n private Task Task4(Pr reporter, Tk token)\n {\n throw new NotImplementedException();\n }\n private Task Task3(Pr reporter, Tk token)\n {\n throw new NotImplementedException();",
"score": 0.8386037349700928
},
{
"filename": "Source/TreeifyTask.BlazorSample/TaskDataModel/code.cs",
"retrieved_chunk": " {\n throw new NotImplementedException();\n }\n private Task Task1(Pr reporter, Tk token)\n {\n throw new NotImplementedException();\n }\n private Task Task1_1(Pr reporter, Tk token)\n {\n throw new NotImplementedException();",
"score": 0.8367950916290283
}
] | csharp | ITaskNode newTask, ITaskNode parentTask)
: base($"Task '{ |
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Memory;
using SKernel.Factory.Config;
using System.Collections.Generic;
using System.Linq;
namespace SKernel.Factory
{
public class SemanticKernelFactory
{
private readonly NativeSkillsImporter _native;
private readonly SemanticSkillsImporter _semantic;
private readonly SKConfig _config;
private readonly IMemoryStore _memoryStore;
private readonly ILogger _logger;
public SemanticKernelFactory(NativeSkillsImporter native, | SemanticSkillsImporter semantic, SKConfig config,
IMemoryStore memoryStore, ILoggerFactory logger)
{ |
_native = native;
_semantic = semantic;
_config = config;
_memoryStore = memoryStore;
_logger = logger.CreateLogger<SemanticKernelFactory>();
}
public IKernel Create(ApiKey key, IList<string>? skills = null)
{
var selected = (skills ?? new List<string>())
.Select(_ => _.ToLower()).ToList();
var kernel = new KernelBuilder()
.WithOpenAI(_config, key)
.WithLogger(_logger)
.Build()
.RegistryCoreSkills(selected)
.Register(_native, selected)
.Register(_semantic, selected);
kernel.UseMemory("embedding", _memoryStore);
return kernel;
}
}
}
| src/SKernel/Factory/SemanticKernelFactory.cs | geffzhang-ai-search-aspnet-qdrant-chatgpt-378d2be | [
{
"filename": "src/SKernel/Factory/SemanticSkillsImporter.cs",
"retrieved_chunk": " public SemanticSkillsImporter(SkillOptions skillOptions, ILoggerFactory logger)\n {\n _folders = skillOptions.SemanticSkillsFolders;\n _logger = logger.CreateLogger<SemanticSkillsImporter>();\n }\n public void ImportSkills(IKernel kernel, IList<string> skills)\n {\n foreach (var folder in _folders)\n kernel.RegisterSemanticSkills(folder, skills, _logger);\n }",
"score": 0.811976432800293
},
{
"filename": "src/SKernel/Factory/NativeSkillsImporter.cs",
"retrieved_chunk": "using Microsoft.SemanticKernel;\nusing SKernel.Factory.Config;\nusing System;\nusing System.Collections.Generic;\nnamespace SKernel.Factory\n{\n public class NativeSkillsImporter : ISkillsImporter\n {\n private readonly IList<Type> _skills;\n private readonly IServiceProvider _provider;",
"score": 0.8007611036300659
},
{
"filename": "src/SKernel/Factory/SemanticSkillsImporter.cs",
"retrieved_chunk": "using Microsoft.Extensions.Logging;\nusing Microsoft.SemanticKernel;\nusing SKernel.Factory.Config;\nusing System.Collections.Generic;\nnamespace SKernel.Factory\n{\n public class SemanticSkillsImporter : ISkillsImporter\n {\n private readonly string[] _folders;\n private readonly ILogger<SemanticSkillsImporter> _logger;",
"score": 0.7992681860923767
},
{
"filename": "src/SKernel/Factory/NativeSkillsImporter.cs",
"retrieved_chunk": " public NativeSkillsImporter(SkillOptions skillOptions, IServiceProvider provider)\n {\n _skills = skillOptions.NativeSkillTypes;\n _provider = provider;\n }\n public void ImportSkills(IKernel kernel, IList<string> skills)\n {\n foreach (var skill in _skills)\n {\n var instance = _provider.GetService(skill);",
"score": 0.7947864532470703
},
{
"filename": "src/SKernel.Services/Extensions.cs",
"retrieved_chunk": " return apiConfig;\n }\n public static bool TryGetKernel(this HttpRequest request, SemanticKernelFactory factory,\n out IKernel? kernel, IList<string>? selected = null)\n {\n var api = request.ToApiKeyConfig();\n kernel = api is { Text: { }, Embedding: { } } ? factory.Create(api, selected) : null;\n return kernel != null;\n }\n public static IResult ToResult(this SKContext result, IList<string>? skills) => (result.ErrorOccurred)",
"score": 0.7668851613998413
}
] | csharp | SemanticSkillsImporter semantic, SKConfig config,
IMemoryStore memoryStore, ILoggerFactory logger)
{ |
using BepInEx;
using UnityEngine;
using UnityEngine.SceneManagement;
using System;
using HarmonyLib;
using System.IO;
using Ultrapain.Patches;
using System.Linq;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Reflection;
using Steamworks;
using Unity.Audio;
using System.Text;
using System.Collections.Generic;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.UIElements;
using PluginConfig.API;
namespace Ultrapain
{
[BepInPlugin(PLUGIN_GUID, PLUGIN_NAME, PLUGIN_VERSION)]
[BepInDependency("com.eternalUnion.pluginConfigurator", "1.6.0")]
public class Plugin : BaseUnityPlugin
{
public const string PLUGIN_GUID = "com.eternalUnion.ultraPain";
public const string PLUGIN_NAME = "Ultra Pain";
public const string PLUGIN_VERSION = "1.1.0";
public static Plugin instance;
private static bool addressableInit = false;
public static T LoadObject<T>(string path)
{
if (!addressableInit)
{
Addressables.InitializeAsync().WaitForCompletion();
addressableInit = true;
}
return Addressables.LoadAssetAsync<T>(path).WaitForCompletion();
}
public static Vector3 PredictPlayerPosition(Collider safeCollider, float speedMod)
{
Transform target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
return target.position;
RaycastHit raycastHit;
if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == safeCollider)
return target.position;
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
return raycastHit.point;
}
else {
Vector3 projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
return new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
}
public static GameObject projectileSpread;
public static GameObject homingProjectile;
public static GameObject hideousMassProjectile;
public static GameObject decorativeProjectile2;
public static GameObject shotgunGrenade;
public static GameObject beam;
public static GameObject turretBeam;
public static GameObject lightningStrikeExplosiveSetup;
public static GameObject lightningStrikeExplosive;
public static GameObject lighningStrikeWindup;
public static GameObject explosion;
public static GameObject bigExplosion;
public static GameObject sandExplosion;
public static GameObject virtueInsignia;
public static GameObject rocket;
public static GameObject revolverBullet;
public static GameObject maliciousCannonBeam;
public static GameObject lightningBoltSFX;
public static GameObject revolverBeam;
public static GameObject blastwave;
public static GameObject cannonBall;
public static GameObject shockwave;
public static GameObject sisyphiusExplosion;
public static GameObject sisyphiusPrimeExplosion;
public static GameObject explosionWaveKnuckleblaster;
public static GameObject chargeEffect;
public static GameObject maliciousFaceProjectile;
public static GameObject hideousMassSpear;
public static GameObject coin;
public static GameObject sisyphusDestroyExplosion;
//public static GameObject idol;
public static GameObject ferryman;
public static GameObject minosPrime;
//public static GameObject maliciousFace;
public static GameObject somethingWicked;
public static Turret turret;
public static GameObject turretFinalFlash;
public static GameObject enrageEffect;
public static GameObject v2flashUnparryable;
public static GameObject ricochetSfx;
public static GameObject parryableFlash;
public static AudioClip cannonBallChargeAudio;
public static Material gabrielFakeMat;
public static Sprite blueRevolverSprite;
public static Sprite greenRevolverSprite;
public static Sprite redRevolverSprite;
public static Sprite blueShotgunSprite;
public static Sprite greenShotgunSprite;
public static Sprite blueNailgunSprite;
public static Sprite greenNailgunSprite;
public static Sprite blueSawLauncherSprite;
public static Sprite greenSawLauncherSprite;
public static GameObject rocketLauncherAlt;
public static GameObject maliciousRailcannon;
// Variables
public static float SoliderShootAnimationStart = 1.2f;
public static float SoliderGrenadeForce = 10000f;
public static float SwordsMachineKnockdownTimeNormalized = 0.8f;
public static float SwordsMachineCoreSpeed = 80f;
public static float MinGrenadeParryVelocity = 40f;
public static GameObject _lighningBoltSFX;
public static | GameObject lighningBoltSFX
{ |
get
{
if (_lighningBoltSFX == null)
_lighningBoltSFX = ferryman.gameObject.transform.Find("LightningBoltChimes").gameObject;
return _lighningBoltSFX;
}
}
private static bool loadedPrefabs = false;
public void LoadPrefabs()
{
if (loadedPrefabs)
return;
loadedPrefabs = true;
// Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab
projectileSpread = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Spread.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab
homingProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab
decorativeProjectile2 = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Decorative 2.prefab");
// Assets/Prefabs/Attacks and Projectiles/Grenade.prefab
shotgunGrenade = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Grenade.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab
turretBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Turret Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
beam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab
lightningStrikeExplosiveSetup = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Lightning Strike Explosive.prefab");
// Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab
lighningStrikeWindup = LoadObject<GameObject>("Assets/Particles/Environment/LightningBoltWindupFollow Variant.prefab");
//[bundle-0][assets/prefabs/enemies/idol.prefab]
//idol = LoadObject<GameObject>("assets/prefabs/enemies/idol.prefab");
// Assets/Prefabs/Enemies/Ferryman.prefab
ferryman = LoadObject<GameObject>("Assets/Prefabs/Enemies/Ferryman.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab
explosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab
bigExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab
sandExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab");
// Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab
virtueInsignia = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Virtue Insignia.prefab");
// Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab
hideousMassProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab");
// Assets/Particles/Enemies/RageEffect.prefab
enrageEffect = LoadObject<GameObject>("Assets/Particles/Enemies/RageEffect.prefab");
// Assets/Particles/Flashes/V2FlashUnparriable.prefab
v2flashUnparryable = LoadObject<GameObject>("Assets/Particles/Flashes/V2FlashUnparriable.prefab");
// Assets/Prefabs/Attacks and Projectiles/Rocket.prefab
rocket = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Rocket.prefab");
// Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab
revolverBullet = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/RevolverBullet.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab
maliciousCannonBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Railcannon Beam Malicious.prefab");
// Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab
revolverBeam = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Revolver Beam.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab
blastwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Enemy.prefab");
// Assets/Prefabs/Enemies/MinosPrime.prefab
minosPrime = LoadObject<GameObject>("Assets/Prefabs/Enemies/MinosPrime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab
cannonBall = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Cannonball.prefab");
// get from Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
cannonBallChargeAudio = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab").transform.Find("RocketLauncher/Armature/Body_Bone/HologramDisplay").GetComponent<AudioSource>().clip;
// Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab
shockwave = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab
sisyphiusExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave Sisyphus.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab
sisyphiusPrimeExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab
explosionWaveKnuckleblaster = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Wave.prefab");
// Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab - [bundle-0][assets/prefabs/explosionlightning variant.prefab]
lightningStrikeExplosive = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab");
// Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab
rocketLauncherAlt = LoadObject<GameObject>("Assets/Prefabs/Weapons/Rocket Launcher Cannonball.prefab");
// Assets/Prefabs/Weapons/Railcannon Malicious.prefab
maliciousRailcannon = LoadObject<GameObject>("Assets/Prefabs/Weapons/Railcannon Malicious.prefab");
//Assets/Particles/SoundBubbles/Ricochet.prefab
ricochetSfx = LoadObject<GameObject>("Assets/Particles/SoundBubbles/Ricochet.prefab");
//Assets/Particles/Flashes/Flash.prefab
parryableFlash = LoadObject<GameObject>("Assets/Particles/Flashes/Flash.prefab");
//Assets/Prefabs/Attacks and Projectiles/Spear.prefab
hideousMassSpear = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Spear.prefab");
//Assets/Prefabs/Enemies/Wicked.prefab
somethingWicked = LoadObject<GameObject>("Assets/Prefabs/Enemies/Wicked.prefab");
//Assets/Textures/UI/SingleRevolver.png
blueRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/SingleRevolver.png");
//Assets/Textures/UI/RevolverSpecial.png
greenRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSpecial.png");
//Assets/Textures/UI/RevolverSharp.png
redRevolverSprite = LoadObject<Sprite>("Assets/Textures/UI/RevolverSharp.png");
//Assets/Textures/UI/Shotgun.png
blueShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun.png");
//Assets/Textures/UI/Shotgun1.png
greenShotgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Shotgun1.png");
//Assets/Textures/UI/Nailgun2.png
blueNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/Nailgun2.png");
//Assets/Textures/UI/NailgunOverheat.png
greenNailgunSprite = LoadObject<Sprite>("Assets/Textures/UI/NailgunOverheat.png");
//Assets/Textures/UI/SawbladeLauncher.png
blueSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncher.png");
//Assets/Textures/UI/SawbladeLauncherOverheat.png
greenSawLauncherSprite = LoadObject<Sprite>("Assets/Textures/UI/SawbladeLauncherOverheat.png");
//Assets/Prefabs/Attacks and Projectiles/Coin.prefab
coin = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Coin.prefab");
//Assets/Materials/GabrielFake.mat
gabrielFakeMat = LoadObject<Material>("Assets/Materials/GabrielFake.mat");
//Assets/Prefabs/Enemies/Turret.prefab
turret = LoadObject<GameObject>("Assets/Prefabs/Enemies/Turret.prefab").GetComponent<Turret>();
//Assets/Particles/Flashes/GunFlashDistant.prefab
turretFinalFlash = LoadObject<GameObject>("Assets/Particles/Flashes/GunFlashDistant.prefab");
//Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab
sisyphusDestroyExplosion = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab");
//Assets/Prefabs/Effects/Charge Effect.prefab
chargeEffect = LoadObject<GameObject>("Assets/Prefabs/Effects/Charge Effect.prefab");
//Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab
maliciousFaceProjectile = LoadObject<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Malicious Beam.prefab");
}
public static bool ultrapainDifficulty = false;
public static bool realUltrapainDifficulty = false;
public static GameObject currentDifficultyButton;
public static GameObject currentDifficultyPanel;
public static Text currentDifficultyInfoText;
public void OnSceneChange(Scene before, Scene after)
{
StyleIDs.RegisterIDs();
ScenePatchCheck();
string mainMenuSceneName = "b3e7f2f8052488a45b35549efb98d902";
string bootSequenceSceneName = "4f8ecffaa98c2614f89922daf31fa22d";
string currentSceneName = SceneManager.GetActiveScene().name;
if (currentSceneName == mainMenuSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Difficulty Select (1)");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach(EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
else if(currentSceneName == bootSequenceSceneName)
{
LoadPrefabs();
//Canvas/Difficulty Select (1)/Violent
Transform difficultySelect = SceneManager.GetActiveScene().GetRootGameObjects().Where(obj => obj.name == "Canvas").First().transform.Find("Intro/Difficulty Select");
GameObject ultrapainButton = GameObject.Instantiate(difficultySelect.Find("Violent").gameObject, difficultySelect);
currentDifficultyButton = ultrapainButton;
ultrapainButton.transform.Find("Name").GetComponent<Text>().text = ConfigManager.pluginName.value;
ultrapainButton.GetComponent<DifficultySelectButton>().difficulty = 5;
RectTransform ultrapainTrans = ultrapainButton.GetComponent<RectTransform>();
ultrapainTrans.anchoredPosition = new Vector2(20f, -104f);
//Canvas/Difficulty Select (1)/Violent Info
GameObject info = GameObject.Instantiate(difficultySelect.Find("Violent Info").gameObject, difficultySelect);
currentDifficultyPanel = info;
currentDifficultyInfoText = info.transform.Find("Text").GetComponent<Text>();
currentDifficultyInfoText.text = ConfigManager.pluginInfo.value;
Text currentDifficultyHeaderText = info.transform.Find("Title (1)").GetComponent<Text>();
currentDifficultyHeaderText.text = $"--{ConfigManager.pluginName.value}--";
currentDifficultyHeaderText.resizeTextForBestFit = true;
currentDifficultyHeaderText.horizontalOverflow = HorizontalWrapMode.Wrap;
currentDifficultyHeaderText.verticalOverflow = VerticalWrapMode.Truncate;
info.SetActive(false);
EventTrigger evt = ultrapainButton.GetComponent<EventTrigger>();
evt.triggers.Clear();
/*EventTrigger.TriggerEvent activate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.TriggerEvent deactivate = new EventTrigger.TriggerEvent();
activate.AddListener((BaseEventData data) => info.SetActive(false));*/
EventTrigger.Entry trigger1 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
trigger1.callback.AddListener((BaseEventData data) => info.SetActive(true));
EventTrigger.Entry trigger2 = new EventTrigger.Entry() { eventID = EventTriggerType.PointerExit };
trigger2.callback.AddListener((BaseEventData data) => info.SetActive(false));
evt.triggers.Add(trigger1);
evt.triggers.Add(trigger2);
foreach (EventTrigger trigger in difficultySelect.GetComponentsInChildren<EventTrigger>())
{
if (trigger.gameObject == ultrapainButton)
continue;
EventTrigger.Entry closeTrigger = new EventTrigger.Entry() { eventID = EventTriggerType.PointerEnter };
closeTrigger.callback.AddListener((BaseEventData data) => info.SetActive(false));
trigger.triggers.Add(closeTrigger);
}
}
// LOAD CUSTOM PREFABS HERE TO AVOID MID GAME LAG
MinosPrimeCharge.CreateDecoy();
GameObject shockwaveSisyphus = SisyphusInstructionist_Start.shockwave;
}
public static class StyleIDs
{
private static bool registered = false;
public static void RegisterIDs()
{
registered = false;
if (MonoSingleton<StyleHUD>.Instance == null)
return;
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.grenadeBoostStyleText.guid, ConfigManager.grenadeBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.rocketBoostStyleText.guid, ConfigManager.rocketBoostStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverStyleText.guid, ConfigManager.orbStrikeRevolverStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeRevolverChargedStyleText.guid, ConfigManager.orbStrikeRevolverChargedStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeElectricCannonStyleText.guid, ConfigManager.orbStrikeElectricCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.orbStrikeMaliciousCannonStyleText.guid, ConfigManager.orbStrikeMaliciousCannonStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.maliciousChargebackStyleText.guid, ConfigManager.maliciousChargebackStyleText.formattedString);
MonoSingleton<StyleHUD>.Instance.RegisterStyleItem(ConfigManager.sentryChargebackStyleText.guid, ConfigManager.sentryChargebackStyleText.formattedString);
registered = true;
Debug.Log("Registered all style ids");
}
private static FieldInfo idNameDict = typeof(StyleHUD).GetField("idNameDict", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
public static void UpdateID(string id, string newName)
{
if (!registered || StyleHUD.Instance == null)
return;
(idNameDict.GetValue(StyleHUD.Instance) as Dictionary<string, string>)[id] = newName;
}
}
public static Harmony harmonyTweaks;
public static Harmony harmonyBase;
private static MethodInfo GetMethod<T>(string name)
{
return typeof(T).GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
private static Dictionary<MethodInfo, HarmonyMethod> methodCache = new Dictionary<MethodInfo, HarmonyMethod>();
private static HarmonyMethod GetHarmonyMethod(MethodInfo method)
{
if (methodCache.TryGetValue(method, out HarmonyMethod harmonyMethod))
return harmonyMethod;
else
{
harmonyMethod = new HarmonyMethod(method);
methodCache.Add(method, harmonyMethod);
return harmonyMethod;
}
}
private static void PatchAllEnemies()
{
if (!ConfigManager.enemyTweakToggle.value)
return;
if (ConfigManager.friendlyFireDamageOverrideToggle.value)
{
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Explosion_Collide_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<PhysicalShockwave>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<PhysicalShockwave_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<VirtueInsignia>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<VirtueInsignia_OnTriggerEnter_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Projectile_Collided_FF>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<Flammable>("Burn"), prefix: GetHarmonyMethod(GetMethod<Flammable_Burn_FF>("Prefix")));
harmonyTweaks.Patch(GetMethod<FireZone>("OnTriggerStay"), prefix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Prefix")), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Fire_FF>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("UpdateModifiers"), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_UpdateModifiers>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Start"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Start_Patch>("Postfix")));
if (ConfigManager.cerberusDashToggle.value)
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopDash"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopDash_Patch>("Postfix")));
if(ConfigManager.cerberusParryable.value)
{
harmonyTweaks.Patch(GetMethod<StatueBoss>("StopTracking"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_StopTracking_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<StatueBoss>("Stomp"), postfix: GetHarmonyMethod(GetMethod<StatueBoss_Stomp_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Statue>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Statue_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Drone_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("Shoot"), prefix: GetHarmonyMethod(GetMethod<Drone_Shoot_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("PlaySound"), prefix: GetHarmonyMethod(GetMethod<Drone_PlaySound_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Update"), postfix: GetHarmonyMethod(GetMethod<Drone_Update>("Postfix")));
if(ConfigManager.droneHomeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Drone_Death_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<Drone_GetHurt_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Ferryman>("Start"), postfix: GetHarmonyMethod(GetMethod<FerrymanStart>("Postfix")));
if(ConfigManager.ferrymanComboToggle.value)
harmonyTweaks.Patch(GetMethod<Ferryman>("StopMoving"), postfix: GetHarmonyMethod(GetMethod<FerrymanStopMoving>("Postfix")));
if(ConfigManager.filthExplodeToggle.value)
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch2>("Prefix")));
if(ConfigManager.fleshPrisonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<FleshPrisonShoot>("Postfix")));
if (ConfigManager.hideousMassInsigniaToggle.value)
{
harmonyTweaks.Patch(GetMethod<Projectile>("Explode"), postfix: GetHarmonyMethod(GetMethod<Projectile_Explode_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mass>("ShootExplosive"), postfix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Postfix")), prefix: GetHarmonyMethod(GetMethod<HideousMassHoming>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<SpiderBody>("Start"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("ChargeBeam"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ChargeBeam>("Postfix")));
harmonyTweaks.Patch(GetMethod<SpiderBody>("BeamChargeEnd"), prefix: GetHarmonyMethod(GetMethod<MaliciousFace_BeamChargeEnd>("Prefix")));
if (ConfigManager.maliciousFaceHomingProjectileToggle.value)
{
harmonyTweaks.Patch(GetMethod<SpiderBody>("ShootProj"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_ShootProj_Patch>("Postfix")));
}
if (ConfigManager.maliciousFaceRadianceOnEnrage.value)
harmonyTweaks.Patch(GetMethod<SpiderBody>("Enrage"), postfix: GetHarmonyMethod(GetMethod<MaliciousFace_Enrage_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("Start"), postfix: GetHarmonyMethod(GetMethod<Mindflayer_Start_Patch>("Postfix")));
if (ConfigManager.mindflayerShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mindflayer>("ShootProjectiles"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_ShootProjectiles_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage_MF>("Prefix")));
}
if (ConfigManager.mindflayerTeleportComboToggle.value)
{
harmonyTweaks.Patch(GetMethod<SwingCheck2>("CheckCollision"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwingCheck2_CheckCollision_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mindflayer>("MeleeTeleport"), prefix: GetHarmonyMethod(GetMethod<Mindflayer_MeleeTeleport_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwingCheck2>("DamageStop"), postfix: GetHarmonyMethod(GetMethod<SwingCheck2_DamageStop_Patch>("Postfix")));
}
if (ConfigManager.minosPrimeRandomTeleportToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("Postfix")));
if (ConfigManager.minosPrimeTeleportTrail.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("Teleport"), postfix: GetHarmonyMethod(GetMethod<MinosPrimeCharge>("TeleportPostfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Start"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Dropkick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Dropkick>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Combo"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_Combo>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("StopAction"), postfix: GetHarmonyMethod(GetMethod<MinosPrime_StopAction>("Postfix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Ascend"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Ascend>("Prefix")));
harmonyTweaks.Patch(GetMethod<MinosPrime>("Death"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_Death>("Prefix")));
if (ConfigManager.minosPrimeCrushAttackToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("RiderKick"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_RiderKick>("Prefix")));
if (ConfigManager.minosPrimeComboExplosiveEndToggle.value)
harmonyTweaks.Patch(GetMethod<MinosPrime>("ProjectileCharge"), prefix: GetHarmonyMethod(GetMethod<MinosPrime_ProjectileCharge>("Prefix")));
if (ConfigManager.schismSpreadAttackToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ShootProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ShootProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<Solider_Start_Patch>("Postfix")));
}
if(ConfigManager.soliderCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_SpawnProjectile_Patch>("Postfix")));
if (ConfigManager.soliderShootGrenadeToggle.value || ConfigManager.soliderShootTweakToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<Solider_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Stalker>("SandExplode"), prefix: GetHarmonyMethod(GetMethod<Stalker_SandExplode_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SandificationZone>("Enter"), postfix: GetHarmonyMethod(GetMethod<SandificationZone_Enter_Patch>("Postfix")));
if (ConfigManager.strayCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SpawnProjectile"), postfix: GetHarmonyMethod(GetMethod<Swing>("Postfix")));
if (ConfigManager.strayShootToggle.value)
{
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("Start"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_Start_Patch1>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("ThrowProjectile"), postfix: GetHarmonyMethod(GetMethod<ZombieProjectile_ThrowProjectile_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<ZombieProjectiles>("DamageEnd"), prefix: GetHarmonyMethod(GetMethod<DamageEnd>("Prefix")));
}
if(ConfigManager.streetCleanerCoinsIgnoreWeakPointToggle.value)
harmonyTweaks.Patch(GetMethod<Streetcleaner>("Start"), postfix: GetHarmonyMethod(GetMethod<StreetCleaner_Start_Patch>("Postfix")));
if(ConfigManager.streetCleanerPredictiveDodgeToggle.value)
harmonyTweaks.Patch(GetMethod<BulletCheck>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<BulletCheck_OnTriggerEnter_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Start"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Start>("Postfix")));
if (ConfigManager.swordsMachineNoLightKnockbackToggle.value || ConfigManager.swordsMachineSecondPhaseMode.value != ConfigManager.SwordsMachineSecondPhase.None)
{
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Knockdown"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Knockdown_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("Down"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_Down_Patch>("Prefix")));
//harmonyTweaks.Patch(GetMethod<SwordsMachine>("SetSpeed"), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_SetSpeed_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<SwordsMachine>("EndFirstPhase"), postfix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Postfix")), prefix: GetHarmonyMethod(GetMethod<SwordsMachine_EndFirstPhase_Patch>("Prefix")));
}
if (ConfigManager.swordsMachineExplosiveSwordToggle.value)
{
harmonyTweaks.Patch(GetMethod<ThrownSword>("Start"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<ThrownSword>("OnTriggerEnter"), postfix: GetHarmonyMethod(GetMethod<ThrownSword_OnTriggerEnter_Patch>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Turret>("Start"), postfix: GetHarmonyMethod(GetMethod<TurretStart>("Postfix")));
if(ConfigManager.turretBurstFireToggle.value)
{
harmonyTweaks.Patch(GetMethod<Turret>("Shoot"), prefix: GetHarmonyMethod(GetMethod<TurretShoot>("Prefix")));
harmonyTweaks.Patch(GetMethod<Turret>("StartAiming"), postfix: GetHarmonyMethod(GetMethod<TurretAim>("Postfix")));
}
harmonyTweaks.Patch(GetMethod<Explosion>("Start"), postfix: GetHarmonyMethod(GetMethod<V2CommonExplosion>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2FirstStart>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2FirstUpdate>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2FirstShootWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("Start"), postfix: GetHarmonyMethod(GetMethod<V2SecondStart>("Postfix")));
//if(ConfigManager.v2SecondStartEnraged.value)
// harmonyTweaks.Patch(GetMethod<BossHealthBar>("OnEnable"), postfix: GetHarmonyMethod(GetMethod<V2SecondEnrage>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("Update"), prefix: GetHarmonyMethod(GetMethod<V2SecondUpdate>("Prefix")));
//harmonyTweaks.Patch(GetMethod<V2>("AltShootWeapon"), postfix: GetHarmonyMethod(GetMethod<V2AltShootWeapon>("Postfix")));
harmonyTweaks.Patch(GetMethod<V2>("SwitchWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondSwitchWeapon>("Prefix")));
harmonyTweaks.Patch(GetMethod<V2>("ShootWeapon"), prefix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Prefix")), postfix: GetHarmonyMethod(GetMethod<V2SecondShootWeapon>("Postfix")));
if(ConfigManager.v2SecondFastCoinToggle.value)
harmonyTweaks.Patch(GetMethod<V2>("ThrowCoins"), prefix: GetHarmonyMethod(GetMethod<V2SecondFastCoin>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<V2RocketLauncher>("CannonBallTriggerPrefix")));
if (ConfigManager.v2FirstSharpshooterToggle.value || ConfigManager.v2SecondSharpshooterToggle.value)
{
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("PrepareAltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverPrepareAltFire>("Prefix")));
harmonyTweaks.Patch(GetMethod<Projectile>("Collided"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverBullet>("Prefix")));
harmonyTweaks.Patch(GetMethod<EnemyRevolver>("AltFire"), prefix: GetHarmonyMethod(GetMethod<V2CommonRevolverAltShoot>("Prefix")));
}
harmonyTweaks.Patch(GetMethod<Drone>("Start"), postfix: GetHarmonyMethod(GetMethod<Virtue_Start_Patch>("Postfix")));
harmonyTweaks.Patch(GetMethod<Drone>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Virtue_SpawnInsignia_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Death"), prefix: GetHarmonyMethod(GetMethod<Virtue_Death_Patch>("Prefix")));
if (ConfigManager.sisyInstJumpShockwave.value)
{
harmonyTweaks.Patch(GetMethod<Sisyphus>("Start"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Sisyphus>("Update"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_Update>("Postfix")));
}
if(ConfigManager.sisyInstBoulderShockwave.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("SetupExplosion"), postfix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_SetupExplosion>("Postfix")));
if(ConfigManager.sisyInstStrongerExplosion.value)
harmonyTweaks.Patch(GetMethod<Sisyphus>("StompExplosion"), prefix: GetHarmonyMethod(GetMethod<SisyphusInstructionist_StompExplosion>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("Awake"), postfix: GetHarmonyMethod(GetMethod<LeviathanTail_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("BigSplash"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_BigSplash>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanTail>("SwingEnd"), prefix: GetHarmonyMethod(GetMethod<LeviathanTail_SwingEnd>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("Start"), postfix: GetHarmonyMethod(GetMethod<Leviathan_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurst"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("ProjectileBurstStart"), prefix: GetHarmonyMethod(GetMethod<Leviathan_ProjectileBurstStart>("Prefix")));
harmonyTweaks.Patch(GetMethod<LeviathanHead>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<Leviathan_FixedUpdate>("Prefix")));
if (ConfigManager.somethingWickedSpear.value)
{
harmonyTweaks.Patch(GetMethod<Wicked>("Start"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<SomethingWicked_GetHit>("Postfix")));
}
if(ConfigManager.somethingWickedSpawnOn43.value)
{
harmonyTweaks.Patch(GetMethod<ObjectActivator>("Activate"), prefix: GetHarmonyMethod(GetMethod<ObjectActivator_Activate>("Prefix")));
harmonyTweaks.Patch(GetMethod<Wicked>("GetHit"), postfix: GetHarmonyMethod(GetMethod<JokeWicked_GetHit>("Postfix")));
}
if (ConfigManager.panopticonFullPhase.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Panopticon_Start>("Postfix")));
if (ConfigManager.panopticonAxisBeam.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnInsignia"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnInsignia>("Prefix")));
if (ConfigManager.panopticonSpinAttackToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("HomingProjectileAttack"), postfix: GetHarmonyMethod(GetMethod<Panopticon_HomingProjectileAttack>("Postfix")));
if (ConfigManager.panopticonBlackholeProj.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnBlackHole"), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnBlackHole>("Postfix")));
if (ConfigManager.panopticonBalanceEyes.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("SpawnFleshDrones"), prefix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Panopticon_SpawnFleshDrones>("Postfix")));
if (ConfigManager.panopticonBlueProjToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Update"), transpiler: GetHarmonyMethod(GetMethod<Panopticon_BlueProjectile>("Transpiler")));
if (ConfigManager.idolExplosionToggle.value)
harmonyTweaks.Patch(GetMethod<Idol>("Death"), postfix: GetHarmonyMethod(GetMethod<Idol_Death_Patch>("Postfix")));
// ADDME
/*
harmonyTweaks.Patch(GetMethod<GabrielSecond>("Start"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("BasicCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_BasicCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("FastCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_FastCombo>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("CombineSwords"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_CombineSwords>("Postfix")));
harmonyTweaks.Patch(GetMethod<GabrielSecond>("ThrowCombo"), postfix: GetHarmonyMethod(GetMethod<GabrielSecond_ThrowCombo>("Postfix")));
*/
}
private static void PatchAllPlayers()
{
if (!ConfigManager.playerTweakToggle.value)
return;
harmonyTweaks.Patch(GetMethod<Punch>("CheckForProjectile"), prefix: GetHarmonyMethod(GetMethod<Punch_CheckForProjectile_Patch>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode_Patch1>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Collision"), prefix: GetHarmonyMethod(GetMethod<Grenade_Collision_Patch>("Prefix")));
if (ConfigManager.rocketBoostToggle.value)
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide_Patch>("Prefix")));
if (ConfigManager.rocketGrabbingToggle.value)
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), prefix: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate_Patch>("Prefix")));
if (ConfigManager.orbStrikeToggle.value)
{
harmonyTweaks.Patch(GetMethod<Coin>("Start"), postfix: GetHarmonyMethod(GetMethod<Coin_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<Punch>("BlastCheck"), prefix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Punch_BlastCheck>("Postfix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_Collide>("Prefix")));
harmonyTweaks.Patch(GetMethod<Coin>("DelayedReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_DelayedReflectRevolver>("Postfix")));
harmonyTweaks.Patch(GetMethod<Coin>("ReflectRevolver"), postfix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Coin_ReflectRevolver>("Prefix")));
harmonyTweaks.Patch(GetMethod<Grenade>("Explode"), prefix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Grenade_Explode>("Postfix")));
harmonyTweaks.Patch(GetMethod<EnemyIdentifier>("DeliverDamage"), prefix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Prefix")), postfix: GetHarmonyMethod(GetMethod<EnemyIdentifier_DeliverDamage>("Postfix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("ExecuteHits"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_ExecuteHits>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("HitSomething"), postfix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Postfix")), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_HitSomething>("Prefix")));
harmonyTweaks.Patch(GetMethod<RevolverBeam>("Start"), prefix: GetHarmonyMethod(GetMethod<RevolverBeam_Start>("Prefix")));
harmonyTweaks.Patch(GetMethod<Cannonball>("Explode"), prefix: GetHarmonyMethod(GetMethod<Cannonball_Explode>("Prefix")));
harmonyTweaks.Patch(GetMethod<Explosion>("Collide"), prefix: GetHarmonyMethod(GetMethod<Explosion_CollideOrbital>("Prefix")));
}
if(ConfigManager.chargedRevRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Revolver>("Update"), prefix: GetHarmonyMethod(GetMethod<Revolver_Update>("Prefix")));
if(ConfigManager.coinRegSpeedMulti.value != 1 || ConfigManager.sharpshooterRegSpeedMulti.value != 1
|| ConfigManager.railcannonRegSpeedMulti.value != 1 || ConfigManager.rocketFreezeRegSpeedMulti.value != 1
|| ConfigManager.rocketCannonballRegSpeedMulti.value != 1 || ConfigManager.nailgunAmmoRegSpeedMulti.value != 1
|| ConfigManager.sawAmmoRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<WeaponCharges>("Charge"), prefix: GetHarmonyMethod(GetMethod<WeaponCharges_Charge>("Prefix")));
if(ConfigManager.nailgunHeatsinkRegSpeedMulti.value != 1 || ConfigManager.sawHeatsinkRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<Nailgun>("Update"), prefix: GetHarmonyMethod(GetMethod<NailGun_Update>("Prefix")));
if(ConfigManager.staminaRegSpeedMulti.value != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("Update"), prefix: GetHarmonyMethod(GetMethod<NewMovement_Update>("Prefix")));
if(ConfigManager.playerHpDeltaToggle.value || ConfigManager.maxPlayerHp.value != 100 || ConfigManager.playerHpSupercharge.value != 200 || ConfigManager.whiplashHardDamageCap.value != 50 || ConfigManager.whiplashHardDamageSpeed.value != 1)
{
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHealth"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHealth>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("SuperCharge"), prefix: GetHarmonyMethod(GetMethod<NewMovement_SuperCharge>("Prefix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Respawn"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Respawn>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("Start"), postfix: GetHarmonyMethod(GetMethod<NewMovement_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Transpiler")));
harmonyTweaks.Patch(GetMethod<HookArm>("FixedUpdate"), transpiler: GetHarmonyMethod(GetMethod<HookArm_FixedUpdate>("Transpiler")));
harmonyTweaks.Patch(GetMethod<NewMovement>("ForceAntiHP"), transpiler: GetHarmonyMethod(GetMethod<NewMovement_ForceAntiHP>("Transpiler")));
}
// ADDME
harmonyTweaks.Patch(GetMethod<Revolver>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Revolver_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Shotgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Transpiler")), prefix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Shotgun_Shoot>("Postfix")));
harmonyTweaks.Patch(GetMethod<Shotgun>("ShootSinks"), transpiler: GetHarmonyMethod(GetMethod<Shotgun_ShootSinks>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("Shoot"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_Shoot>("Transpiler")));
harmonyTweaks.Patch(GetMethod<Nailgun>("SuperSaw"), transpiler: GetHarmonyMethod(GetMethod<Nailgun_SuperSaw>("Transpiler")));
if (ConfigManager.hardDamagePercent.normalizedValue != 1)
harmonyTweaks.Patch(GetMethod<NewMovement>("GetHurt"), prefix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Prefix")), postfix: GetHarmonyMethod(GetMethod<NewMovement_GetHurt>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Start"), postfix: GetHarmonyMethod(GetMethod<HealthBar_Start>("Postfix")));
harmonyTweaks.Patch(GetMethod<HealthBar>("Update"), transpiler: GetHarmonyMethod(GetMethod<HealthBar_Update>("Transpiler")));
foreach (HealthBarTracker hb in HealthBarTracker.instances)
{
if (hb != null)
hb.SetSliderRange();
}
harmonyTweaks.Patch(GetMethod<Harpoon>("Start"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Start>("Postfix")));
if(ConfigManager.screwDriverHomeToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("Punched"), postfix: GetHarmonyMethod(GetMethod<Harpoon_Punched>("Postfix")));
if(ConfigManager.screwDriverSplitToggle.value)
harmonyTweaks.Patch(GetMethod<Harpoon>("OnTriggerEnter"), prefix: GetHarmonyMethod(GetMethod<Harpoon_OnTriggerEnter_Patch>("Prefix")));
}
private static void PatchAllMemes()
{
if (ConfigManager.enrageSfxToggle.value)
harmonyTweaks.Patch(GetMethod<EnrageEffect>("Start"), postfix: GetHarmonyMethod(GetMethod<EnrageEffect_Start>("Postfix")));
if(ConfigManager.funnyDruidKnightSFXToggle.value)
{
harmonyTweaks.Patch(GetMethod<Mandalore>("FullBurst"), postfix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Postfix")), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Mandalore>("FullerBurst"), prefix: GetHarmonyMethod(GetMethod<DruidKnight_FullerBurst>("Prefix")));
harmonyTweaks.Patch(GetMethod<Drone>("Explode"), prefix: GetHarmonyMethod(GetMethod<Drone_Explode>("Prefix")), postfix: GetHarmonyMethod(GetMethod<Drone_Explode>("Postfix")));
}
if (ConfigManager.fleshObamiumToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<FleshObamium_Start>("Prefix")));
if (ConfigManager.obamapticonToggle.value)
harmonyTweaks.Patch(GetMethod<FleshPrison>("Start"), postfix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Postfix")), prefix: GetHarmonyMethod(GetMethod<Obamapticon_Start>("Prefix")));
}
public static bool methodsPatched = false;
public static void ScenePatchCheck()
{
if(methodsPatched && !ultrapainDifficulty)
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
}
else if(!methodsPatched && ultrapainDifficulty)
{
PatchAll();
}
}
public static void PatchAll()
{
harmonyTweaks.UnpatchSelf();
methodsPatched = false;
if (!ultrapainDifficulty)
return;
if(realUltrapainDifficulty && ConfigManager.discordRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<DiscordController>("SendActivity"), prefix: GetHarmonyMethod(GetMethod<DiscordController_SendActivity_Patch>("Prefix")));
if (realUltrapainDifficulty && ConfigManager.steamRichPresenceToggle.value)
harmonyTweaks.Patch(GetMethod<SteamFriends>("SetRichPresence"), prefix: GetHarmonyMethod(GetMethod<SteamFriends_SetRichPresence_Patch>("Prefix")));
PatchAllEnemies();
PatchAllPlayers();
PatchAllMemes();
methodsPatched = true;
}
public static string workingPath;
public static string workingDir;
public static AssetBundle bundle;
public static AudioClip druidKnightFullAutoAud;
public static AudioClip druidKnightFullerAutoAud;
public static AudioClip druidKnightDeathAud;
public static AudioClip enrageAudioCustom;
public static GameObject fleshObamium;
public static GameObject obamapticon;
public void Awake()
{
instance = this;
workingPath = Assembly.GetExecutingAssembly().Location;
workingDir = Path.GetDirectoryName(workingPath);
Logger.LogInfo($"Working path: {workingPath}, Working dir: {workingDir}");
try
{
bundle = AssetBundle.LoadFromFile(Path.Combine(workingDir, "ultrapain"));
druidKnightFullAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullauto.wav");
druidKnightFullerAutoAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/fullerauto.wav");
druidKnightDeathAud = bundle.LoadAsset<AudioClip>("assets/ultrapain/druidknight/death.wav");
enrageAudioCustom = bundle.LoadAsset<AudioClip>("assets/ultrapain/sfx/enraged.wav");
fleshObamium = bundle.LoadAsset<GameObject>("assets/ultrapain/fleshprison/fleshobamium.prefab");
obamapticon = bundle.LoadAsset<GameObject>("assets/ultrapain/panopticon/obamapticon.prefab");
}
catch (Exception e)
{
Logger.LogError($"Could not load the asset bundle:\n{e}");
}
// DEBUG
/*string logPath = Path.Combine(Environment.CurrentDirectory, "log.txt");
Logger.LogInfo($"Saving to {logPath}");
List<string> assetPaths = new List<string>()
{
"fonts.bundle",
"videos.bundle",
"shaders.bundle",
"particles.bundle",
"materials.bundle",
"animations.bundle",
"prefabs.bundle",
"physicsmaterials.bundle",
"models.bundle",
"textures.bundle",
};
//using (FileStream log = File.Open(logPath, FileMode.OpenOrCreate, FileAccess.Write))
//{
foreach(string assetPath in assetPaths)
{
Logger.LogInfo($"Attempting to load {assetPath}");
AssetBundle bundle = AssetBundle.LoadFromFile(Path.Combine(bundlePath, assetPath));
bundles.Add(bundle);
//foreach (string name in bundle.GetAllAssetNames())
//{
// string line = $"[{bundle.name}][{name}]\n";
// log.Write(Encoding.ASCII.GetBytes(line), 0, line.Length);
//}
bundle.LoadAllAssets();
}
//}
*/
// Plugin startup logic
Logger.LogInfo($"Plugin {PluginInfo.PLUGIN_GUID} is loaded!");
harmonyTweaks = new Harmony(PLUGIN_GUID + "_tweaks");
harmonyBase = new Harmony(PLUGIN_GUID + "_base");
harmonyBase.Patch(GetMethod<DifficultySelectButton>("SetDifficulty"), postfix: GetHarmonyMethod(GetMethod<DifficultySelectPatch>("Postfix")));
harmonyBase.Patch(GetMethod<DifficultyTitle>("Check"), postfix: GetHarmonyMethod(GetMethod<DifficultyTitle_Check_Patch>("Postfix")));
harmonyBase.Patch(typeof(PrefsManager).GetConstructor(new Type[0]), postfix: GetHarmonyMethod(GetMethod<PrefsManager_Ctor>("Postfix")));
harmonyBase.Patch(GetMethod<PrefsManager>("EnsureValid"), prefix: GetHarmonyMethod(GetMethod<PrefsManager_EnsureValid>("Prefix")));
harmonyBase.Patch(GetMethod<Grenade>("Explode"), prefix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Prefix")), postfix: new HarmonyMethod(GetMethod<GrenadeExplosionOverride>("Postfix")));
LoadPrefabs();
ConfigManager.Initialize();
SceneManager.activeSceneChanged += OnSceneChange;
}
}
public static class Tools
{
private static Transform _target;
private static Transform target { get
{
if(_target == null)
_target = MonoSingleton<PlayerTracker>.Instance.GetTarget();
return _target;
}
}
public static Vector3 PredictPlayerPosition(float speedMod, Collider enemyCol = null)
{
Vector3 projectedPlayerPos;
if (MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude == 0f)
{
return target.position;
}
RaycastHit raycastHit;
if (enemyCol != null && Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, 4096, QueryTriggerInteraction.Collide) && raycastHit.collider == enemyCol)
{
projectedPlayerPos = target.position;
}
else if (Physics.Raycast(target.position, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(), out raycastHit, MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity().magnitude * 0.35f / speedMod, LayerMaskDefaults.Get(LMD.EnvironmentAndBigEnemies), QueryTriggerInteraction.Collide))
{
projectedPlayerPos = raycastHit.point;
}
else
{
projectedPlayerPos = target.position + MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity() * 0.35f / speedMod;
projectedPlayerPos = new Vector3(projectedPlayerPos.x, target.transform.position.y + (target.transform.position.y - projectedPlayerPos.y) * 0.5f, projectedPlayerPos.z);
}
return projectedPlayerPos;
}
}
// Asset destroyer tracker
/*[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass1
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.Destroy), new Type[] { typeof(UnityEngine.Object), typeof(float) })]
public class TempClass2
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object) })]
public class TempClass3
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}
[HarmonyPatch(typeof(UnityEngine.Object), nameof(UnityEngine.Object.DestroyImmediate), new Type[] { typeof(UnityEngine.Object), typeof(bool) })]
public class TempClass4
{
static void Postfix(UnityEngine.Object __0)
{
if (__0 != null && __0 == Plugin.homingProjectile)
{
System.Diagnostics.StackTrace t = new System.Diagnostics.StackTrace();
Debug.LogError("Projectile destroyed");
Debug.LogError(t.ToString());
throw new Exception("Attempted to destroy proj");
}
}
}*/
}
| Ultrapain/Plugin.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/Stray.cs",
"retrieved_chunk": " /*__instance.projectile = Plugin.homingProjectile;\n __instance.decProjectile = Plugin.decorativeProjectile2;*/\n }\n }\n public class ZombieProjectile_ThrowProjectile_Patch\n {\n public static float normalizedTime = 0f;\n public static float animSpeed = 20f;\n public static float projectileSpeed = 75;\n public static float turnSpeedMultiplier = 0.45f;",
"score": 0.880786657333374
},
{
"filename": "Ultrapain/Patches/CommonComponents.cs",
"retrieved_chunk": " public float superSize = 1f;\n public float superSpeed = 1f;\n public float superDamage = 1f;\n public int superPlayerDamageOverride = -1;\n struct StateInfo\n {\n public GameObject tempHarmless;\n public GameObject tempNormal;\n public GameObject tempSuper;\n public StateInfo()",
"score": 0.8677200078964233
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static FloatField idolExplosionSizeMultiplier;\n public static FloatField idolExplosionDamageMultiplier;\n public static FloatSliderField idolExplosionEnemyDamagePercent;\n /////////// ADD MEEEE\n // GABRIEL SECOND\n public static BoolField gabriSecondP1Chaos;\n public static IntField gabriSecondP1ChaosCount;\n private static bool dirtyField = false;\n public static void Initialize()\n {",
"score": 0.8567361831665039
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public static ConfigPanel leviathanPanel;\n public static ConfigPanel somethingWickedPanel;\n public static ConfigPanel panopticonPanel;\n public static ConfigPanel idolPanel;\n // GLOBAL ENEMY CONFIG\n public static BoolField friendlyFireDamageOverrideToggle;\n public static FloatSliderField friendlyFireDamageOverrideExplosion;\n public static FloatSliderField friendlyFireDamageOverrideProjectile;\n public static FloatSliderField friendlyFireDamageOverrideFire;\n public static FloatSliderField friendlyFireDamageOverrideMelee;",
"score": 0.847016453742981
},
{
"filename": "Ultrapain/Patches/Leviathan.cs",
"retrieved_chunk": " {\n private LeviathanHead comp;\n private Animator anim;\n //private Collider col;\n private LayerMask envMask = new LayerMask() { value = 1 << 8 | 1 << 24 };\n public float playerRocketRideTracker = 0;\n private GameObject currentProjectileEffect;\n private AudioSource currentProjectileAud;\n private Transform shootPoint;\n public float currentProjectileSize = 0;",
"score": 0.8463322520256042
}
] | csharp | GameObject lighningBoltSFX
{ |
using System.Xml.Linq;
using LibreDteDotNet.RestRequest.Interfaces;
namespace LibreDteDotNet.RestRequest.Extensions
{
public static class FolioCafExtension
{
private static CancellationToken CancellationToken { get; set; }
public static | IFolioCaf Conectar(this IFolioCaf instance)
{ |
return instance.SetCookieCertificado().Result;
}
public static async Task<XDocument> Descargar(this Task<IFolioCaf> instance)
{
return await (await instance).Descargar();
}
public static async Task<IFolioCaf> Confirmar(this Task<IFolioCaf> instance)
{
return await (await instance).Confirmar();
}
}
}
| LibreDteDotNet.RestRequest/Extensions/FolioCafExtension.cs | sergiokml-LibreDteDotNet.RestRequest-6843109 | [
{
"filename": "LibreDteDotNet.RestRequest/Extensions/DTEExtension.cs",
"retrieved_chunk": "using LibreDteDotNet.Common.Models;\nusing LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class DTEExtension\n {\n public static IDTE Conectar(this IDTE folioService)\n {\n IDTE instance = folioService;\n return instance.SetCookieCertificado().ConfigureAwait(false).GetAwaiter().GetResult();",
"score": 0.8780064582824707
},
{
"filename": "LibreDteDotNet.RestRequest/Extensions/BoletaExtension.cs",
"retrieved_chunk": "using LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class BoletaExtension\n {\n public static IBoleta Conectar(this IBoleta folioService)\n {\n IBoleta instance = folioService;\n return instance.SetCookieCertificado().Result;\n }",
"score": 0.8766539096832275
},
{
"filename": "LibreDteDotNet.RestRequest/Interfaces/IFolioCaf.cs",
"retrieved_chunk": "using System.Xml.Linq;\nusing static LibreDteDotNet.Common.ComunEnum;\nnamespace LibreDteDotNet.RestRequest.Interfaces\n{\n public interface IFolioCaf\n {\n public Dictionary<string, string> InputsText { get; set; }\n Task<string> GetHistorial(string rut, string dv, TipoDoc tipodoc);\n Task<IFolioCaf> ReObtener(\n string rut,",
"score": 0.8665585517883301
},
{
"filename": "LibreDteDotNet.RestRequest/Extensions/ContribuyenteExtension.cs",
"retrieved_chunk": "using LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Extensions\n{\n public static class ContribuyenteExtension\n {\n public static IContribuyente Conectar(this IContribuyente folioService)\n {\n IContribuyente instance = folioService;\n return instance.SetCookieCertificado().Result;\n }",
"score": 0.8661608695983887
},
{
"filename": "LibreDteDotNet.RestRequest/Infraestructure/RestRequest.cs",
"retrieved_chunk": "using LibreDteDotNet.RestRequest.Interfaces;\nnamespace LibreDteDotNet.RestRequest.Infraestructure\n{\n public class RestRequest\n {\n public ILibro Libro { get; }\n public IContribuyente Contribuyente { get; }\n public IFolioCaf FolioCaf { get; }\n public IBoleta Boleta { get; }\n public IDTE DocumentoTributario { get; }",
"score": 0.8629561066627502
}
] | csharp | IFolioCaf Conectar(this IFolioCaf instance)
{ |
using System.Text.Json.Serialization;
namespace LibreDteDotNet.RestRequest.Models.Response
{
public class DataResp
{
[JsonPropertyName("detalles")]
public List< | Detalle>? Detalles { | get; set; }
[JsonPropertyName("totMntExe")]
public long TotMntExe { get; set; }
[JsonPropertyName("totMntNeto")]
public long TotMntNeto { get; set; }
[JsonPropertyName("totMntIVA")]
public long TotMntIVA { get; set; }
[JsonPropertyName("totMntTotal")]
public long TotMntTotal { get; set; }
}
}
| LibreDteDotNet.RestRequest/Models/Response/DataResp.cs | sergiokml-LibreDteDotNet.RestRequest-6843109 | [
{
"filename": "LibreDteDotNet.RestRequest/Models/Response/ResLibroDetalle.cs",
"retrieved_chunk": "using System.Text.Json.Serialization;\nnamespace LibreDteDotNet.RestRequest.Models.Response\n{\n public class ResLibroDetalle\n {\n [JsonPropertyName(\"data\")]\n public object Data { get; set; }\n [JsonPropertyName(\"dataResp\")]\n public DataResp DataResp { get; set; }\n [JsonPropertyName(\"dataReferencias\")]",
"score": 0.9060568809509277
},
{
"filename": "LibreDteDotNet.RestRequest/Models/Request/ReqLibroResumenCsv.cs",
"retrieved_chunk": "using System.Text.Json.Serialization;\nusing LibreDteDotNet.RestRequest.Models.Response;\nnamespace LibreDteDotNet.RestRequest.Models.Request\n{\n public class ReqLibroResumenCsv\n {\n [JsonPropertyName(\"data\")]\n public List<string>? Data { get; set; }\n [JsonPropertyName(\"metaData\")]\n public ResMetaDataLibroResumen? MetaData { get; set; }",
"score": 0.8943033218383789
},
{
"filename": "LibreDteDotNet.RestRequest/Models/Response/ResLibroResumen.cs",
"retrieved_chunk": "using System.Text.Json.Serialization;\nnamespace LibreDteDotNet.RestRequest.Models.Response\n{\n public class ResLibroResumen\n {\n [JsonPropertyName(\"data\")]\n public ResDataLibroResumen? Data { get; set; }\n [JsonPropertyName(\"metaData\")]\n public ResMetaDataLibroResumen? MetaData { get; set; }\n [JsonPropertyName(\"respEstado\")]",
"score": 0.876399040222168
},
{
"filename": "LibreDteDotNet.RestRequest/Models/Response/ResDataLibroResumen.cs",
"retrieved_chunk": "using System.Text.Json.Serialization;\nnamespace LibreDteDotNet.RestRequest.Models.Response\n{\n public class ResDataLibroResumen\n {\n [JsonPropertyName(\"resumenDte\")]\n public List<ResResumenDte>? ResumenDte { get; set; }\n [JsonPropertyName(\"datosAsync\")]\n public object? DatosAsync { get; set; }\n }",
"score": 0.8744560480117798
},
{
"filename": "LibreDteDotNet.RestRequest/Models/Request/ReqDataLibroDetalle.cs",
"retrieved_chunk": "using System.Text.Json.Serialization;\nnamespace LibreDteDotNet.RestRequest.Models.Request\n{\n public class ReqDataLibroDetalle\n {\n [JsonPropertyName(\"tipoDoc\")]\n public string? TipoDoc { get; set; }\n [JsonPropertyName(\"rut\")]\n public string? Rut { get; set; }\n [JsonPropertyName(\"dv\")]",
"score": 0.8665869832038879
}
] | csharp | Detalle>? Detalles { |
// Kaplan Copyright (c) DragonFruit Network <[email protected]>
// Licensed under Apache-2. Refer to the LICENSE file for more info
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;
using Windows.ApplicationModel;
using Windows.Management.Deployment;
using Avalonia.Media;
using DragonFruit.Kaplan.ViewModels.Enums;
using DragonFruit.Kaplan.ViewModels.Messages;
using DynamicData.Binding;
using Microsoft.Extensions.Logging;
using Nito.AsyncEx;
using ReactiveUI;
namespace DragonFruit.Kaplan.ViewModels
{
public class RemovalProgressViewModel : ReactiveObject, IHandlesClosingEvent, IExecutesTaskPostLoad, ICanCloseWindow
{
private readonly ILogger _logger = App.GetLogger<RemovalProgressViewModel>();
private readonly AsyncLock _lock = new();
private readonly PackageInstallationMode _mode;
private readonly CancellationTokenSource _cancellation = new();
private readonly ObservableAsPropertyHelper<ISolidColorBrush> _progressColor;
private OperationState _status;
private int _currentPackageNumber;
private PackageRemovalTask _current;
public RemovalProgressViewModel(IEnumerable<Package> packages, PackageInstallationMode mode)
{
_mode = mode;
_status = OperationState.Pending;
_progressColor = this.WhenValueChanged(x => x.Status).Select(x => x switch
{
OperationState.Pending => Brushes.Gray,
OperationState.Running => Brushes.DodgerBlue,
OperationState.Errored => Brushes.Red,
OperationState.Completed => Brushes.Green,
OperationState.Canceled => Brushes.DarkGray,
_ => throw new ArgumentOutOfRangeException(nameof(x), x, null)
}).ToProperty(this, x => x.ProgressColor);
var canCancelOperation = this.WhenAnyValue(x => x.CancellationRequested, x => x.Status)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => !x.Item1 && x.Item2 == OperationState.Running);
Packages = packages.ToList();
RequestCancellation = ReactiveCommand.Create(CancelOperation, canCancelOperation);
}
public event Action CloseRequested;
public PackageRemovalTask Current
{
get => _current;
private set => this.RaiseAndSetIfChanged(ref _current, value);
}
public int CurrentPackageNumber
{
get => _currentPackageNumber;
private set => this.RaiseAndSetIfChanged(ref _currentPackageNumber, value);
}
public OperationState Status
{
get => _status;
private set => this.RaiseAndSetIfChanged(ref _status, value);
}
public bool CancellationRequested => _cancellation.IsCancellationRequested;
public ISolidColorBrush ProgressColor => _progressColor.Value;
public IReadOnlyList<Package> Packages { get; }
public ICommand RequestCancellation { get; }
private void CancelOperation()
{
_cancellation.Cancel();
this.RaisePropertyChanged(nameof(CancellationRequested));
}
void | IHandlesClosingEvent.OnClose(CancelEventArgs args)
{ |
args.Cancel = Status == OperationState.Running;
}
async Task IExecutesTaskPostLoad.Perform()
{
_logger.LogInformation("Removal process started");
_logger.LogDebug("Waiting for lock access");
using (await _lock.LockAsync(_cancellation.Token).ConfigureAwait(false))
{
Status = OperationState.Running;
var manager = new PackageManager();
for (var i = 0; i < Packages.Count; i++)
{
if (CancellationRequested)
{
break;
}
CurrentPackageNumber = i + 1;
Current = new PackageRemovalTask(manager, Packages[i], _mode);
try
{
_logger.LogInformation("Starting removal of {packageId}", Current.Package.Id);
#if DRY_RUN
await Task.Delay(1000, _cancellation.Token).ConfigureAwait(false);
#else
await Current.RemoveAsync(_cancellation.Token).ConfigureAwait(false);
#endif
}
catch (OperationCanceledException)
{
_logger.LogInformation("Package removal cancelled by user (stopped at {packageId})", Current.Package.Id);
}
catch (Exception ex)
{
Status = OperationState.Errored;
_logger.LogError(ex, "Package removal failed: {err}", ex.Message);
break;
}
}
}
Status = CancellationRequested ? OperationState.Canceled : OperationState.Completed;
MessageBus.Current.SendMessage(new PackageRefreshEventArgs());
_logger.LogInformation("Package removal process ended: {state}", Status);
await Task.Delay(1000).ConfigureAwait(false);
CloseRequested?.Invoke();
}
}
public enum OperationState
{
Pending,
Running,
Errored,
Completed,
Canceled
}
} | DragonFruit.Kaplan/ViewModels/RemovalProgressViewModel.cs | dragonfruitnetwork-kaplan-13bdb39 | [
{
"filename": "DragonFruit.Kaplan/Views/RemovalProgress.axaml.cs",
"retrieved_chunk": " public RemovalProgress()\n {\n InitializeComponent();\n }\n protected override void OnOpened(EventArgs e)\n {\n if (DataContext is ICanCloseWindow windowCloser)\n {\n windowCloser.CloseRequested += () => Dispatcher.UIThread.InvokeAsync(Close);\n }",
"score": 0.821153998374939
},
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " /// </summary>\n public string SearchQuery\n {\n get => _searchQuery;\n set => this.RaiseAndSetIfChanged(ref _searchQuery, value);\n }\n public ICommand ShowAbout { get; }\n public ICommand ClearSelection { get; }\n public ICommand RemovePackages { get; }\n public ICommand RefreshPackages { get; }",
"score": 0.8029911518096924
},
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " }\n private void RemovePackagesImpl()\n {\n var packages = SelectedPackages.Select(x => x.Package).ToList();\n var args = new UninstallEventArgs(packages, PackageMode);\n _logger.LogInformation(\"Starting removal of {x} packages\", packages.Count);\n MessageBus.Current.SendMessage(args);\n }\n public void Dispose()\n {",
"score": 0.8005510568618774
},
{
"filename": "DragonFruit.Kaplan/Views/RemovalProgress.axaml.cs",
"retrieved_chunk": " (DataContext as IExecutesTaskPostLoad)?.Perform();\n }\n protected override void OnClosing(WindowClosingEventArgs e)\n {\n (DataContext as IHandlesClosingEvent)?.OnClose(e);\n }\n }\n}",
"score": 0.7905019521713257
},
{
"filename": "DragonFruit.Kaplan/App.axaml.cs",
"retrieved_chunk": " public partial class App : Application\n {\n public static App Instance => (App)Current;\n private ILoggerFactory Logger { get; set; }\n public bool BugReportingEnabled { get; set; } = true;\n public static ILogger GetLogger<T>()\n {\n return Instance.Logger.CreateLogger<T>();\n }\n public override void Initialize()",
"score": 0.7821662425994873
}
] | csharp | IHandlesClosingEvent.OnClose(CancelEventArgs args)
{ |
using FayElf.Plugins.WeChat.OfficialAccount.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XiaoFeng;
using XiaoFeng.Http;
/****************************************************************
* Copyright © (2022) www.fayelf.com All Rights Reserved. *
* Author : jacky *
* QQ : 7092734 *
* Email : [email protected] *
* Site : www.fayelf.com *
* Create Time : 2022-03-18 08:56:16 *
* Version : v 1.0.0 *
* CLR Version : 4.0.30319.42000 *
*****************************************************************/
namespace FayElf.Plugins.WeChat.OfficialAccount
{
/// <summary>
/// 模板消息操作类
/// </summary>
public class Template
{
#region 构造器
/// <summary>
/// 无参构造器
/// </summary>
public Template()
{
this.Config = Config.Current;
}
/// <summary>
/// 设置配置
/// </summary>
/// <param name="config">配置</param>
public Template(Config config)
{
this.Config = config;
}
#endregion
#region 属性
/// <summary>
/// 配置
/// </summary>
public Config Config { get; set; }
#endregion
#region 方法
#region 设置所属行业
/// <summary>
/// 设置所属行业
/// </summary>
/// <param name="industry1">公众号模板消息所属行业编号</param>
/// <param name="industry2">公众号模板消息所属行业编号</param>
/// <returns></returns>
public | BaseResult SetIndustry(Industry industry1,Industry industry2)
{ |
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method= HttpMethod.Post,
Address=$"https://api.weixin.qq.com/cgi-bin/template/api_set_industry?access_token={token.AccessToken}",
BodyData = $@"{{""industry_id1"":""{(int)industry1}"",""industry_id2"":""{(int)industry2}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<BaseResult>();
}
else
{
return new BaseResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获取设置的行业信息
/*
* {
"primary_industry":{"first_class":"运输与仓储","second_class":"快递"},
"secondary_industry":{"first_class":"IT科技","second_class":"互联网|电子商务"}
}
*/
/// <summary>
/// 获取设置的行业信息
/// </summary>
/// <returns></returns>
public IndustryModelResult GetIndustry()
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Get,
Address = $"https://api.weixin.qq.com/cgi-bin/template/get_industry?access_token={token.AccessToken}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryModelResult>();
}
else
{
return new IndustryModelResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获得模板ID
/// <summary>
/// 获得模板ID
/// </summary>
/// <param name="templateId">模板库中模板的编号，有“TM**”和“OPENTMTM**”等形式</param>
/// <returns></returns>
public IndustryTemplateResult AddTemplate(string templateId)
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/template/api_add_template?access_token={token.AccessToken}",
BodyData = $@"{{""template_id_short"":""{templateId}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateResult>();
}
else
{
return new IndustryTemplateResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 获取模板列表
/// <summary>
/// 获取模板列表
/// </summary>
/// <returns></returns>
public IndustryTemplateListResult GetAllPrivateTemplate()
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Get,
Address = $"https://api.weixin.qq.com/cgi-bin/template/api_add_template?access_token={token.AccessToken}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateListResult>();
}
else
{
return new IndustryTemplateListResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
}
#endregion
#region 删除模板
/// <summary>
/// 删除模板
/// </summary>
/// <param name="templateId">公众帐号下模板消息ID</param>
/// <returns></returns>
public Boolean DeletePrivateTemplate(string templateId)
{
var config = this.Config.GetConfig(WeChatType.Applets);
var result = Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/template/del_private_template?access_token={token.AccessToken}",
BodyData = $@"{{""template_id"":""{templateId}""}}"
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<BaseResult>();
}
else
{
return new BaseResult
{
ErrCode = 500,
ErrMsg = "请求失败."
};
}
});
return result.ErrCode == 0;
}
#endregion
#region 发送模板消息
/// <summary>
/// 发送模板消息
/// </summary>
/// <param name="data">发送数据</param>
/// <returns></returns>
public IndustryTemplateSendDataResult Send(IndustryTemplateSendData data)
{
var config = this.Config.GetConfig(WeChatType.Applets);
return Common.Execute(config.AppID, config.AppSecret, token =>
{
var response = HttpHelper.GetHtml(new HttpRequest
{
Method = HttpMethod.Post,
Address = $"https://api.weixin.qq.com/cgi-bin/message/template/send?access_token={token.AccessToken}",
BodyData = data.ToJson()
});
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return response.Html.JsonToObject<IndustryTemplateSendDataResult>();
}
else
{
return new IndustryTemplateSendDataResult
{
ErrCode = 500,
ErrMsg = "请求出错."
};
}
});
}
#endregion
#endregion
}
} | OfficialAccount/Template.cs | zhuovi-FayElf.Plugins.WeChat-5725d1e | [
{
"filename": "OfficialAccount/Model/IndustryTemplateListResult.cs",
"retrieved_chunk": " /// <summary>\n /// 模板所属行业的一级行业\n /// </summary>\n [Description(\"模板所属行业的一级行业\"), JsonElement(\"primary_industry\")]\n public string PrimaryIndustry { get; set; }\n /// <summary>\n /// 模板所属行业的二级行业\n /// </summary>\n [Description(\"模板所属行业的二级行业\"), JsonElement(\"deputy_industry\")]\n public string DeputyIndustry { get; set; }",
"score": 0.8458901643753052
},
{
"filename": "OfficialAccount/Model/IndustryModelResult.cs",
"retrieved_chunk": " }\n #endregion\n #region 属性\n /// <summary>\n /// 帐号设置的主营行业\n /// </summary>\n [Description(\"帐号设置的主营行业\")]\n [JsonElement(\"primary_industry\")]\n public IndustryCategoryModel PrimaryIndustry { get; set; }\n /// <summary>",
"score": 0.7930126190185547
},
{
"filename": "OfficialAccount/Model/IndustryModelResult.cs",
"retrieved_chunk": " /// 帐号设置的副营行业\n /// </summary>\n [Description(\"帐号设置的副营行业\")]\n [JsonElement(\"secondary_industry\")]\n public IndustryCategoryModel SecondaryIndustry { get; set; }\n #endregion\n #region 方法\n #endregion\n }\n /// <summary>",
"score": 0.7824323177337646
},
{
"filename": "OfficialAccount/Subscribe.cs",
"retrieved_chunk": " /// </summary>\n /// <param name=\"tid\">模板标题 id，可通过getPubTemplateTitleList接口获取，也可登录公众号后台查看获取</param>\n /// <param name=\"kidList\">开发者自行组合好的模板关键词列表，关键词顺序可以自由搭配（例如 [3,5,4] 或 [4,5,3]），最多支持5个，最少2个关键词组合</param>\n /// <param name=\"sceneDesc\">服务场景描述，15个字以内</param>\n /// <returns></returns>\n public AddTemplateResult AddTemplate(string tid, int kidList, string sceneDesc)\n {\n var config = this.Config.GetConfig(WeChatType.Applets);\n return Common.Execute(config.AppID, config.AppSecret, token =>\n {",
"score": 0.7789433002471924
},
{
"filename": "OfficialAccount/OAuthAPI.cs",
"retrieved_chunk": " }\n }\n #endregion\n #region 拉取用户信息(需scope为 snsapi_userinfo)\n /// <summary>\n /// 拉取用户信息(需scope为 snsapi_userinfo)\n /// </summary>\n /// <param name=\"accessToken\">网页授权接口调用凭证,注意：此access_token与基础支持的access_token不同</param>\n /// <param name=\"openId\">用户的唯一标识</param>\n /// <param name=\"lang\">返回国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语</param>",
"score": 0.774298906326294
}
] | csharp | BaseResult SetIndustry(Industry industry1,Industry industry2)
{ |
using Microsoft.AspNetCore.Mvc;
using WebApi.Models;
using WebApi.Services;
namespace WebApi.Controllers
{
[Route("api/[controller]")]
[ApiController]
[Consumes("application/json")]
[Produces("application/json")]
public class ChatController : ControllerBase
{
private readonly IValidationService _validation;
private readonly IOpenAIService _openai;
private readonly ILogger<ChatController> _logger;
public ChatController(IValidationService validation, IOpenAIService openai, ILogger<ChatController> logger)
{
this._validation = validation ?? throw new ArgumentNullException(nameof(validation));
this._openai = openai ?? throw new ArgumentNullException(nameof(openai));
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
[HttpPost("completions", Name = "ChatCompletions")]
[ProducesResponseType(typeof(ChatCompletionResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof( | ErrorResponse), StatusCodes.Status403Forbidden)]
public async Task<IActionResult> Post([FromBody] ChatCompletionRequest req)
{ |
var validation = this._validation.ValidateHeaders<ChatCompletionRequestHeaders>(this.Request.Headers);
if (validation.Validated != true)
{
return await Task.FromResult(validation.ActionResult);
}
var pvr = this._validation.ValidatePayload(req);
if (pvr.Validated != true)
{
return await Task.FromResult(pvr.ActionResult);
}
var res = await this._openai.GetChatCompletionAsync(pvr.Payload.Prompt);
return new OkObjectResult(res);
}
}
} | src/IssueSummaryApi/Controllers/ChatController.cs | Azure-Samples-vs-apim-cuscon-powerfx-500a170 | [
{
"filename": "src/IssueSummaryApi/Controllers/GitHubController.cs",
"retrieved_chunk": " [HttpGet(\"issues\", Name = \"Issues\")]\n [ProducesResponseType(typeof(GitHubIssueCollectionResponse), StatusCodes.Status200OK)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status401Unauthorized)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status403Forbidden)]\n public async Task<IActionResult> GetIssues([FromQuery] GitHubApiRequestQueries req)\n {\n var hvr = this._validation.ValidateHeaders<GitHubApiRequestHeaders>(this.Request.Headers);\n if (hvr.Validated != true)\n {\n return await Task.FromResult(hvr.ActionResult);",
"score": 0.8617057204246521
},
{
"filename": "src/IssueSummaryApi/Controllers/GitHubController.cs",
"retrieved_chunk": " [ProducesResponseType(typeof(GitHubIssueItemResponse), StatusCodes.Status200OK)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status401Unauthorized)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status403Forbidden)]\n public async Task<IActionResult> GetIssue(int id, [FromQuery] GitHubApiRequestQueries req)\n {\n var validation = this._validation.ValidateHeaders<GitHubApiRequestHeaders>(this.Request.Headers);\n if (validation.Validated != true)\n {\n return await Task.FromResult(validation.ActionResult);\n }",
"score": 0.8469976186752319
},
{
"filename": "src/IssueSummaryApi/Controllers/GitHubController.cs",
"retrieved_chunk": " [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status401Unauthorized)]\n [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status403Forbidden)]\n public async Task<IActionResult> GetIssueSummary(int id, [FromQuery] GitHubApiRequestQueries req)\n {\n var validation = this._validation.ValidateHeaders<GitHubApiRequestHeaders>(this.Request.Headers);\n if (validation.Validated != true)\n {\n return await Task.FromResult(validation.ActionResult);\n }\n var qvr = this._validation.ValidateQueries(req);",
"score": 0.817357063293457
},
{
"filename": "src/IssueSummaryApi/Services/OpenAIService.cs",
"retrieved_chunk": " private readonly IOpenAIHelper _helper;\n public OpenAIService(IOpenAIHelper helper)\n {\n this._helper = helper ?? throw new ArgumentNullException(nameof(helper));\n }\n public async Task<ChatCompletionResponse> GetChatCompletionAsync(string prompt)\n {\n var res = await this._helper.GetChatCompletionAsync(prompt);\n return res;\n }",
"score": 0.7791996002197266
},
{
"filename": "src/IssueSummaryApi/Controllers/GitHubController.cs",
"retrieved_chunk": " var qvr = this._validation.ValidateQueries(req);\n if (qvr.Validated != true)\n {\n return await Task.FromResult(qvr.ActionResult);\n }\n var res = await this._github.GetIssueAsync(id, validation.Headers, qvr.Queries);\n return new OkObjectResult(res);\n }\n [HttpGet(\"issues/{id}/summary\", Name = \"IssueSummaryById\")]\n [ProducesResponseType(typeof(GitHubIssueItemSummaryResponse), StatusCodes.Status200OK)]",
"score": 0.7472568154335022
}
] | csharp | ErrorResponse), StatusCodes.Status403Forbidden)]
public async Task<IActionResult> Post([FromBody] ChatCompletionRequest req)
{ |
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Orchestration;
using System.Threading.Tasks;
namespace SKernel.Factory
{
public class DefaultPlanExecutor : IPlanExecutor
{
public async Task<SKContext> Execute(IKernel kernel, | Message message, int iterations)
{ |
SKContext plan = await kernel.RunAsync(message.Variables.ToContext(), kernel.CreatePlan());
var iteration = 0;
var executePlan = kernel.ExecutePlan();
var result = await kernel.RunAsync(plan.Variables, executePlan);
while (!result.Variables.ToPlan().IsComplete && result.Variables.ToPlan().IsSuccessful &&
iteration < iterations - 1)
{
result = await kernel.RunAsync(result.Variables, executePlan);
iteration++;
}
return result;
}
}
}
| src/SKernel/Factory/DefaultPlanExecutor.cs | geffzhang-ai-search-aspnet-qdrant-chatgpt-378d2be | [
{
"filename": "src/SKernel/Factory/NativeSkillsImporter.cs",
"retrieved_chunk": "using Microsoft.SemanticKernel;\nusing SKernel.Factory.Config;\nusing System;\nusing System.Collections.Generic;\nnamespace SKernel.Factory\n{\n public class NativeSkillsImporter : ISkillsImporter\n {\n private readonly IList<Type> _skills;\n private readonly IServiceProvider _provider;",
"score": 0.857379674911499
},
{
"filename": "src/SKernel/KernelExtensions.cs",
"retrieved_chunk": "using System.Threading.Tasks;\nnamespace SKernel\n{\n public static partial class Extensions\n {\n internal static ISKFunction CreatePlan(this IKernel kernel) =>\n kernel.Skills.GetFunction(\"plannerskill\", \"createplan\");\n internal static ISKFunction ExecutePlan(this IKernel kernel) =>\n kernel.Skills.GetFunction(\"plannerskill\", \"executeplan\");\n internal static ContextVariables ToContext(this IEnumerable<KeyValuePair<string, string>> variables)",
"score": 0.8571246862411499
},
{
"filename": "src/SKernel/Factory/SemanticSkillsImporter.cs",
"retrieved_chunk": "using Microsoft.Extensions.Logging;\nusing Microsoft.SemanticKernel;\nusing SKernel.Factory.Config;\nusing System.Collections.Generic;\nnamespace SKernel.Factory\n{\n public class SemanticSkillsImporter : ISkillsImporter\n {\n private readonly string[] _folders;\n private readonly ILogger<SemanticSkillsImporter> _logger;",
"score": 0.8565078377723694
},
{
"filename": "src/SKernel.Services/Extensions.cs",
"retrieved_chunk": "using Microsoft.SemanticKernel.Orchestration;\nusing Microsoft.SemanticKernel;\nusing SKernel.Factory.Config;\nusing SKernel.Factory;\nusing Microsoft.AspNetCore.Http;\nnamespace SKernel.Service\n{\n public static class Extensions\n {\n public static ApiKey ToApiKeyConfig(this HttpRequest request)",
"score": 0.8535292744636536
},
{
"filename": "src/SKernel/Factory/ISkillsImporter.cs",
"retrieved_chunk": "using Microsoft.SemanticKernel;\nusing System.Collections.Generic;\nnamespace SKernel.Factory\n{\n public interface ISkillsImporter\n {\n void ImportSkills(IKernel kernel, IList<string> skills);\n }\n}",
"score": 0.8499003648757935
}
] | csharp | Message message, int iterations)
{ |
using System.Collections.Generic;
namespace JdeJabali.JXLDataTableExtractor.JXLExtractedData
{
public class JXLWorksheetData
{
public string WorksheetName { get; set; } = string.Empty;
public List< | JXLExtractedRow> Rows { | get; set; } = new List<JXLExtractedRow>();
}
} | JdeJabali.JXLDataTableExtractor/JXLExtractedData/JXLWorksheetData.cs | JdeJabali-JXLDataTableExtractor-90a12f4 | [
{
"filename": "JdeJabali.JXLDataTableExtractor/JXLExtractedData/JXLWorkbookData.cs",
"retrieved_chunk": "using System.Collections.Generic;\nnamespace JdeJabali.JXLDataTableExtractor.JXLExtractedData\n{\n public class JXLWorkbookData\n {\n public string WorkbookPath { get; set; } = string.Empty;\n public string WorkbookName { get; set; } = string.Empty;\n public List<JXLWorksheetData> WorksheetsData { get; set; } = new List<JXLWorksheetData>();\n }\n}",
"score": 0.9445791840553284
},
{
"filename": "JdeJabali.JXLDataTableExtractor/JXLExtractedData/JXLExtractedRow.cs",
"retrieved_chunk": "using System.Collections.Generic;\nnamespace JdeJabali.JXLDataTableExtractor.JXLExtractedData\n{\n public class JXLExtractedRow\n {\n public Dictionary<string, string> Columns { get; set; } = new Dictionary<string, string>();\n }\n}",
"score": 0.9351811408996582
},
{
"filename": "JdeJabali.JXLDataTableExtractor/JXLExtractedData/JXLDataExtracted.cs",
"retrieved_chunk": "using System.Collections.Generic;\nnamespace JdeJabali.JXLDataTableExtractor.JXLExtractedData\n{\n public class JXLDataExtracted\n {\n public List<JXLWorkbookData> WorkbooksData { get; set; } = new List<JXLWorkbookData>();\n }\n}",
"score": 0.9256588220596313
},
{
"filename": "JdeJabali.JXLDataTableExtractor/Configuration/IDataExtraction.cs",
"retrieved_chunk": "using JdeJabali.JXLDataTableExtractor.JXLExtractedData;\nusing System.Collections.Generic;\nusing System.Data;\nnamespace JdeJabali.JXLDataTableExtractor.Configuration\n{\n public interface IDataExtraction\n {\n /// <summary>\n /// Extract all the data from the workbook(s).\n /// </summary>",
"score": 0.8612058162689209
},
{
"filename": "JdeJabali.JXLDataTableExtractor/Exceptions/DuplicateWorkbookException.cs",
"retrieved_chunk": "using System;\nusing System.Runtime.Serialization;\nnamespace JdeJabali.JXLDataTableExtractor.Exceptions\n{\n [Serializable]\n public class DuplicateWorkbookException : Exception\n {\n public DuplicateWorkbookException()\n {\n }",
"score": 0.8552266955375671
}
] | csharp | JXLExtractedRow> Rows { |
using Newtonsoft.Json;
using TaskSummarizer.Shared.Models;
namespace TaskSummarizer.Shared.Helpers
{
public static class OpenAiHelpers
{
/// <summary>
/// Get the system message
/// </summary>
/// <param name="baseSystemMessage"></param>
/// <returns></returns>
private static string GetSystemMessage(string baseSystemMessage)
{
var systemMessage = $"<|im_start|>system\n{baseSystemMessage.Trim()}\n<|im_end|>";
return systemMessage;
}
/// <summary>
/// Create a prompt from the system message and messages.
/// </summary>
/// <param name="systemMessage">The system message.</param>
/// <param name="message">
/// The list of messages, each represented as a dynamic object with "sender" and "text" keys.
/// Example: messages = [{"sender": "user", "text": "I want to write a blog post about my company."}]
///</param>
/// <returns>The prompt string.</returns>
private static string CreatePrompt(dynamic message, string systemMessage)
{
var prompt = systemMessage;
prompt += $"\n<|im_start|>{message["sender"]}\n{message["text"]}<|im_end|>";
prompt += "\n<|im_start|>assistant\n";
return prompt;
}
public static string GetPromptFromTasks(List< | TaskItem> taskItems, string baseSystemMessage)
{ |
var tasks = JsonConvert.SerializeObject(taskItems, Formatting.Indented);
var systemMessage = GetSystemMessage(baseSystemMessage);
const string intro = "Here are the tasks done, generate the summary in 2-4 bullet points, in prose format:";
var serializedTasks = JsonConvert.SerializeObject(taskItems, Formatting.Indented);
var userMessage = new Dictionary<string, string>()
{
{ "sender", "user" },
{ "text", $"{intro}\n\n{serializedTasks}" }
};
var prompt = CreatePrompt(userMessage, systemMessage);
return prompt;
}
public static string GetAdaptiveCardPrompt(string tasksSummary, string baseSystemMessage)
{
var systemMessage = GetSystemMessage(baseSystemMessage);
const string intro = "Here is the summary of the work done";
var userMessage = new Dictionary<string, string>()
{
{ "sender", "user" },
{ "text", $"{intro}\n\n{tasksSummary}" }
};
var prompt = CreatePrompt(userMessage, systemMessage);
return prompt;
}
// Todo: Estimate number of tokens in a prompt
}
}
| src/TasksSummarizer/TaskSummarizer.Shared/Helpers/OpenAiHelpers.cs | Jcardif-DailyTaskSummary-5d3f785 | [
{
"filename": "src/TasksSummarizer/TasksSummarizer.Functions/Functions/SummarizeTasksHttpTrigger.cs",
"retrieved_chunk": " .AddEnvironmentVariables()\n .Build();\n var apiKey = config.GetValue<string>(\"AzureOpenAI:APIKey\");\n var deploymentId = config.GetValue<string>(\"AzureOpenAI:DeploymentId\");\n var baseUrl = config.GetValue<string>(\"AzureOpenAI:BaseUrl\");\n var filePath = Path.Combine(Environment.CurrentDirectory, \"Prompts\", \"SummarizeText.txt\");\n var baseSystemMessage = await File.ReadAllTextAsync(filePath);\n baseSystemMessage = baseSystemMessage.Replace(\"Peter Parker\", name);\n var chatService = new OpenAiChatService(apiKey, baseUrl, deploymentId);\n var prompt = GetPromptFromTasks(items, baseSystemMessage);",
"score": 0.637628436088562
},
{
"filename": "src/TasksSummarizer/TasksSummarizer.Functions/Functions/SummarizeTasksHttpTrigger.cs",
"retrieved_chunk": " var openAiResponse = await chatService.CreateCompletionAsync(prompt);\n var summary = new { taskSummary = openAiResponse?.Choices?.FirstOrDefault()?.Text ?? \"\" };\n response = req.CreateResponse(HttpStatusCode.OK);\n await response.WriteAsJsonAsync(summary); \n return response;\n }\n }\n}",
"score": 0.6349648237228394
},
{
"filename": "src/TasksSummarizer/TasksSummarizer.Functions/Functions/GetCollaboratorsHttpTrigger.cs",
"retrieved_chunk": " private readonly ILogger _logger;\n public GetCollaboratorsHttpTrigger(ILoggerFactory loggerFactory)\n {\n _logger = loggerFactory.CreateLogger<GetCollaboratorsHttpTrigger>();\n }\n [Function(\"GetCollaboratorsHttpTrigger\")]\n public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, \"post\")] HttpRequestData req)\n {\n var requestBody = await new StreamReader(req.Body).ReadToEndAsync();\n var data = JsonConvert.DeserializeObject<dynamic>(requestBody);",
"score": 0.6183819770812988
},
{
"filename": "src/TasksSummarizer/TasksSummarizer.Functions/Functions/GenerateAdaptiveCardHttpTrigger.cs",
"retrieved_chunk": " var deploymentId = config.GetValue<string>(\"AzureOpenAI:DeploymentId\");\n var baseUrl = config.GetValue<string>(\"AzureOpenAI:BaseUrl\");\n var filePath = Path.Combine(Environment.CurrentDirectory, \"Prompts\", \"GenerateAdaptiveCard.txt\");\n var baseSystemMessage = await File.ReadAllTextAsync(filePath);\n var chatService = new OpenAiChatService(apiKey, baseUrl, deploymentId);\n var prompt = GetAdaptiveCardPrompt(taskSummary, baseSystemMessage);\n var openAiResponse = await chatService.CreateCompletionAsync(prompt);\n var text = openAiResponse?.Choices?.FirstOrDefault()?.Text;\n var card = EnsureBraces(text ?? \"{}\");\n response = req.CreateResponse(HttpStatusCode.OK);",
"score": 0.6153971552848816
},
{
"filename": "src/TasksSummarizer/TaskSummarizer.Shared/Services/HttpDataService.cs",
"retrieved_chunk": " return JsonConvert.DeserializeObject<T>(content);\n }\n throw new HttpRequestException($\"Error calling {uri} - {response.StatusCode}\");\n }\n public async Task<string?> PostAsJsonAsync<T>(string uri, T item, string apiKey)\n {\n var jsonBody = JsonConvert.SerializeObject(item);\n var httpContent = new StringContent(jsonBody, Encoding.UTF8, \"application/json\");\n httpContent.Headers.Add(\"api-key\", apiKey);\n var response = await _client.PostAsync(\"\", httpContent);",
"score": 0.6133568286895752
}
] | csharp | TaskItem> taskItems, string baseSystemMessage)
{ |
// Kaplan Copyright (c) DragonFruit Network <[email protected]>
// Licensed under Apache-2. Refer to the LICENSE file for more info
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;
using Windows.ApplicationModel;
using Windows.Management.Deployment;
using Avalonia.Media;
using DragonFruit.Kaplan.ViewModels.Enums;
using DragonFruit.Kaplan.ViewModels.Messages;
using DynamicData.Binding;
using Microsoft.Extensions.Logging;
using Nito.AsyncEx;
using ReactiveUI;
namespace DragonFruit.Kaplan.ViewModels
{
public class RemovalProgressViewModel : ReactiveObject, IHandlesClosingEvent, IExecutesTaskPostLoad, ICanCloseWindow
{
private readonly ILogger _logger = App.GetLogger<RemovalProgressViewModel>();
private readonly AsyncLock _lock = new();
private readonly PackageInstallationMode _mode;
private readonly CancellationTokenSource _cancellation = new();
private readonly ObservableAsPropertyHelper<ISolidColorBrush> _progressColor;
private OperationState _status;
private int _currentPackageNumber;
private PackageRemovalTask _current;
public RemovalProgressViewModel(IEnumerable<Package> packages, PackageInstallationMode mode)
{
_mode = mode;
_status = OperationState.Pending;
_progressColor = this.WhenValueChanged(x => x.Status).Select(x => x switch
{
OperationState.Pending => Brushes.Gray,
OperationState.Running => Brushes.DodgerBlue,
OperationState.Errored => Brushes.Red,
OperationState.Completed => Brushes.Green,
OperationState.Canceled => Brushes.DarkGray,
_ => throw new ArgumentOutOfRangeException(nameof(x), x, null)
}).ToProperty(this, x => x.ProgressColor);
var canCancelOperation = this.WhenAnyValue(x => x.CancellationRequested, x => x.Status)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => !x.Item1 && x.Item2 == OperationState.Running);
Packages = packages.ToList();
RequestCancellation = ReactiveCommand.Create(CancelOperation, canCancelOperation);
}
public event Action CloseRequested;
public | PackageRemovalTask Current
{ |
get => _current;
private set => this.RaiseAndSetIfChanged(ref _current, value);
}
public int CurrentPackageNumber
{
get => _currentPackageNumber;
private set => this.RaiseAndSetIfChanged(ref _currentPackageNumber, value);
}
public OperationState Status
{
get => _status;
private set => this.RaiseAndSetIfChanged(ref _status, value);
}
public bool CancellationRequested => _cancellation.IsCancellationRequested;
public ISolidColorBrush ProgressColor => _progressColor.Value;
public IReadOnlyList<Package> Packages { get; }
public ICommand RequestCancellation { get; }
private void CancelOperation()
{
_cancellation.Cancel();
this.RaisePropertyChanged(nameof(CancellationRequested));
}
void IHandlesClosingEvent.OnClose(CancelEventArgs args)
{
args.Cancel = Status == OperationState.Running;
}
async Task IExecutesTaskPostLoad.Perform()
{
_logger.LogInformation("Removal process started");
_logger.LogDebug("Waiting for lock access");
using (await _lock.LockAsync(_cancellation.Token).ConfigureAwait(false))
{
Status = OperationState.Running;
var manager = new PackageManager();
for (var i = 0; i < Packages.Count; i++)
{
if (CancellationRequested)
{
break;
}
CurrentPackageNumber = i + 1;
Current = new PackageRemovalTask(manager, Packages[i], _mode);
try
{
_logger.LogInformation("Starting removal of {packageId}", Current.Package.Id);
#if DRY_RUN
await Task.Delay(1000, _cancellation.Token).ConfigureAwait(false);
#else
await Current.RemoveAsync(_cancellation.Token).ConfigureAwait(false);
#endif
}
catch (OperationCanceledException)
{
_logger.LogInformation("Package removal cancelled by user (stopped at {packageId})", Current.Package.Id);
}
catch (Exception ex)
{
Status = OperationState.Errored;
_logger.LogError(ex, "Package removal failed: {err}", ex.Message);
break;
}
}
}
Status = CancellationRequested ? OperationState.Canceled : OperationState.Completed;
MessageBus.Current.SendMessage(new PackageRefreshEventArgs());
_logger.LogInformation("Package removal process ended: {state}", Status);
await Task.Delay(1000).ConfigureAwait(false);
CloseRequested?.Invoke();
}
}
public enum OperationState
{
Pending,
Running,
Errored,
Completed,
Canceled
}
} | DragonFruit.Kaplan/ViewModels/RemovalProgressViewModel.cs | dragonfruitnetwork-kaplan-13bdb39 | [
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " var packagesSelected = SelectedPackages.ToObservableChangeSet()\n .ToCollection()\n .ObserveOn(RxApp.MainThreadScheduler)\n .Select(x => x.Any());\n _packageRefreshListener = MessageBus.Current.Listen<UninstallEventArgs>().ObserveOn(RxApp.TaskpoolScheduler).Subscribe(x => RefreshPackagesImpl());\n _displayedPackages = this.WhenAnyValue(x => x.DiscoveredPackages, x => x.SearchQuery, x => x.SelectedPackages)\n .ObserveOn(RxApp.TaskpoolScheduler)\n .Select(q =>\n {\n // because filters remove selected entries, the search will split the listing into two groups, with the matches showing above",
"score": 0.8699270486831665
},
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " var matches = q.Item1.ToLookup(x => x.IsSearchMatch(q.Item2));\n return matches[true].Concat(matches[false]);\n })\n .ToProperty(this, x => x.DisplayedPackages);\n // create commands\n RefreshPackages = ReactiveCommand.CreateFromTask(RefreshPackagesImpl);\n RemovePackages = ReactiveCommand.Create(RemovePackagesImpl, packagesSelected);\n ClearSelection = ReactiveCommand.Create(() => SelectedPackages.Clear(), packagesSelected);\n ShowAbout = ReactiveCommand.Create(() => MessageBus.Current.SendMessage(new ShowAboutWindowEventArgs()));\n // auto refresh the package list if the user package filter switch is changed",
"score": 0.8640620708465576
},
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " this.WhenValueChanged(x => x.PackageMode).ObserveOn(RxApp.TaskpoolScheduler).Subscribe(_ => RefreshPackages.Execute(null));\n }\n public IEnumerable<PackageInstallationMode> AvailablePackageModes { get; }\n public ObservableCollection<PackageViewModel> SelectedPackages { get; } = new();\n public IEnumerable<PackageViewModel> DisplayedPackages => _displayedPackages.Value;\n private IReadOnlyCollection<PackageViewModel> DiscoveredPackages\n {\n get => _discoveredPackages;\n set => this.RaiseAndSetIfChanged(ref _discoveredPackages, value);\n }",
"score": 0.834414005279541
},
{
"filename": "DragonFruit.Kaplan/ViewModels/MainWindowViewModel.cs",
"retrieved_chunk": " // ensure the ui doesn't have non-existent packages nominated through an intersection\n // ToList needed due to deferred nature of iterators used.\n var reselectedPackages = filteredPackageModels.IntersectBy(SelectedPackages.Select(x => x.Package.Id.FullName), x => x.Package.Id.FullName).ToList();\n await Dispatcher.UIThread.InvokeAsync(() =>\n {\n SelectedPackages.Clear();\n SearchQuery = string.Empty;\n DiscoveredPackages = filteredPackageModels;\n SelectedPackages.AddRange(reselectedPackages);\n });",
"score": 0.7959586977958679
},
{
"filename": "DragonFruit.Kaplan/Views/MainWindow.axaml.cs",
"retrieved_chunk": " {\n DataContext = new RemovalProgressViewModel(args.Packages, args.Mode)\n };\n await window.ShowDialog(this).ConfigureAwait(false);\n MessageBus.Current.SendMessage(new PackageRefreshEventArgs());\n }\n private void PackageListPropertyChanged(object sender, AvaloniaPropertyChangedEventArgs e)\n {\n if (e.Property.Name != nameof(ListBox.ItemsSource))\n {",
"score": 0.7877914905548096
}
] | csharp | PackageRemovalTask Current
{ |
#nullable enable
using System.Collections.Generic;
using System.Linq;
using Mochineko.ChatGPT_API;
using Mochineko.LLMAgent.Summarization;
using Newtonsoft.Json;
using UnityEditor;
using UnityEngine;
namespace Mochineko.LLMAgent.Operation.Editor
{
internal sealed class LongTermMemoryEditor : EditorWindow
{
[MenuItem("Mochineko/LLMAgent/LongTermMemory")]
private static void Open()
{
GetWindow<LongTermMemoryEditor>("LongTermMemory");
}
private | DemoOperator? demoOperator; |
private Vector2 totalScrollPosition;
private Vector2 promptsScrollPosition;
private Vector2 shortTermMemoriesScrollPosition;
private Vector2 bufferMemoriesScrollPosition;
private Vector2 summaryScrollPosition;
private void OnGUI()
{
demoOperator = EditorGUILayout.ObjectField(
"DemoOperator",
demoOperator,
typeof(DemoOperator),
true)
as DemoOperator;
EditorGUILayout.Space();
if (demoOperator == null)
{
EditorGUILayout.LabelField("Please specify demo operator...");
return;
}
EditorGUILayout.Space();
var memory = demoOperator.Memory;
if (memory == null)
{
EditorGUILayout.LabelField("Please start demo operator...");
return;
}
EditorGUILayout.Space();
using var totalScroll = new EditorGUILayout.ScrollViewScope(totalScrollPosition, GUI.skin.box);
totalScrollPosition = totalScroll.scrollPosition;
EditorGUILayout.LabelField($"Total tokens:{memory.TotalMemoriesTokenLength}");
EditorGUILayout.Space();
EditorGUILayout.LabelField($"Prompts:");
if (GUILayout.Button("Copy to clipboard"))
{
CopyConversationJsonToClipboard(memory.Prompts);
}
using (var scope = new EditorGUILayout.ScrollViewScope(promptsScrollPosition, GUI.skin.box))
{
promptsScrollPosition = scope.scrollPosition;
EditorGUILayout.LabelField($"Tokens:{memory.PromptsTokenLength}");
using (new EditorGUI.DisabledGroupScope(true))
{
foreach (var prompt in memory.Prompts)
{
EditorGUILayout.TextArea($"{prompt.Content}");
}
}
}
EditorGUILayout.Space();
EditorGUILayout.LabelField($"Short Term Memory:");
if (GUILayout.Button("Copy to clipboard"))
{
CopyConversationJsonToClipboard(memory.ShortTermMemories);
}
using (var scope = new EditorGUILayout.ScrollViewScope(shortTermMemoriesScrollPosition, GUI.skin.box))
{
shortTermMemoriesScrollPosition = scope.scrollPosition;
EditorGUILayout.LabelField($"Tokens:{memory.ShortTermMemoriesTokenLength}");
using (new EditorGUI.DisabledGroupScope(true))
{
foreach (var message in memory.ShortTermMemories)
{
EditorGUILayout.TextArea($"{message.Role} > {message.Content}");
}
}
}
EditorGUILayout.Space();
EditorGUILayout.LabelField($"Buffer Memory:");
if (GUILayout.Button("Copy to clipboard"))
{
CopyConversationJsonToClipboard(memory.BufferMemories);
}
using (var scope = new EditorGUILayout.ScrollViewScope(bufferMemoriesScrollPosition, GUI.skin.box))
{
bufferMemoriesScrollPosition = scope.scrollPosition;
EditorGUILayout.LabelField($"Tokens:{memory.BufferMemoriesTokenLength}");
using (new EditorGUI.DisabledGroupScope(true))
{
foreach (var message in memory.BufferMemories)
{
EditorGUILayout.TextArea($"{message.Role} > {message.Content}");
}
}
}
EditorGUILayout.Space();
EditorGUILayout.LabelField($"Summary:");
if (GUILayout.Button("Copy to clipboard"))
{
CopyToClipboard(memory.Summary.Content);
}
using (var scope = new EditorGUILayout.ScrollViewScope(summaryScrollPosition, GUI.skin.box))
{
summaryScrollPosition = scope.scrollPosition;
EditorGUILayout.LabelField($"Tokens:{memory.SummaryTokenLength}");
using (new EditorGUI.DisabledGroupScope(true))
{
EditorGUILayout.TextArea($"{memory.Summary.Content}");
}
}
}
private static void CopyConversationJsonToClipboard(IEnumerable<Message> messages)
{
var conversations = new ConversationCollection(messages.ToList());
var json = JsonConvert.SerializeObject(conversations);
EditorGUIUtility.systemCopyBuffer = json;
Debug.Log($"Copy json to clipboard:{json}");
}
private static void CopyToClipboard(string text)
{
EditorGUIUtility.systemCopyBuffer = text;
Debug.Log($"Copy text to clipboard:{text}");
}
}
} | Assets/Mochineko/LLMAgent/Operation/Editor/LongTermMemoryEditor.cs | mochi-neko-llm-agent-sandbox-unity-6521c0b | [
{
"filename": "Assets/Mochineko/LLMAgent/Memory/LongTermChatMemory.cs",
"retrieved_chunk": "using UnityEngine;\nnamespace Mochineko.LLMAgent.Memory\n{\n public sealed class LongTermChatMemory : IChatMemory\n {\n private readonly int maxShortTermMemoriesTokenLength;\n private readonly int maxBufferMemoriesTokenLength;\n private readonly TikToken tikToken;\n private readonly List<Message> prompts = new();\n internal IEnumerable<Message> Prompts => prompts.ToArray();",
"score": 0.8251172304153442
},
{
"filename": "Assets/Mochineko/LLMAgent/Operation/DemoOperator.cs",
"retrieved_chunk": "using UnityEngine;\nusing UniVRM10;\nusing VRMShaders;\nnamespace Mochineko.LLMAgent.Operation\n{\n internal sealed class DemoOperator : MonoBehaviour\n {\n [SerializeField] private Model model = Model.Turbo;\n [SerializeField, TextArea] private string prompt = string.Empty;\n [SerializeField, TextArea] private string defaultConversations = string.Empty;",
"score": 0.7760837078094482
},
{
"filename": "Assets/Mochineko/LLMAgent/Operation/StateResultsExtension.cs",
"retrieved_chunk": "#nullable enable\nusing Mochineko.Relent.Result;\nusing Mochineko.RelentStateMachine;\nnamespace Mochineko.LLMAgent.Operation\n{\n // TODO: Apply original state machine\n public static class StateResultsExtension<TEvent>\n {\n public static ISuccessResult<IEventRequest<TEvent>> Succeed { get; }\n = Results.Succeed(EventRequests.None<TEvent>());",
"score": 0.7756731510162354
},
{
"filename": "Assets/Mochineko/LLMAgent/Memory/TokenizerExtensions.cs",
"retrieved_chunk": "#nullable enable\nusing System.Collections.Generic;\nusing Mochineko.ChatGPT_API;\nusing TiktokenSharp;\nnamespace Mochineko.LLMAgent.Memory\n{\n public static class TokenizerExtensions\n {\n public static int TokenLength(\n this IEnumerable<Message> messages,",
"score": 0.7754424810409546
},
{
"filename": "Assets/Mochineko/LLMAgent/Memory/OnMemoryChatMemoryStore.cs",
"retrieved_chunk": "#nullable enable\nusing System.Threading;\nusing Cysharp.Threading.Tasks;\nusing Mochineko.Relent.Result;\nnamespace Mochineko.LLMAgent.Memory\n{\n public sealed class OnMemoryChatMemoryStore : IChatMemoryStore\n {\n private string memory = string.Empty;\n public UniTask<IResult<string>> LoadAsync(CancellationToken cancellationToken)",
"score": 0.7720040082931519
}
] | csharp | DemoOperator? demoOperator; |
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NVA.Enums;
using NVA.Models;
using NVA.Services;
namespace NVA.Bots
{
public class Bot : ActivityHandler
{
// Seconds to wait before starting to do incremental updates.
private const int UPDATE_INITIAL_DELAY_SECS = 7;
private const string CONVERSATION_TYPE_CHANNEL = "channel";
private readonly | ConversationManager _conversationManager; |
// Task source for piping incremental updates.
private volatile TaskCompletionSource<string> _sentenceUpdate;
public Bot(ConversationManager conversationManager)
{
_conversationManager = conversationManager;
_sentenceUpdate = new TaskCompletionSource<string>();
}
protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(turnContext.Activity.Text))
{
return;
}
// is it a chat or a channel
bool isChannel = turnContext.Activity.Conversation.ConversationType == CONVERSATION_TYPE_CHANNEL;
if (!isChannel)
{
// Bot typing indicator.
await turnContext.SendActivityAsync(new Activity { Type = ActivityTypes.Typing }, cancellationToken).ConfigureAwait(false);
}
// Intially we want to wait for a minimum time before sending an update, so combine sentence update event with delay task.
var updateWaitTask = WaitSentenceUpdate(withDelay: true);
// Start generating chat response.
var generateTask = _conversationManager.GenerateResponse(turnContext, SentenceUpdateCallback, cancellationToken);
string answerId = null;
bool generateComplete = false;
do
{
// Wait till either generation is complete or an incremental update arrives.
var update = await Task.WhenAny(generateTask, updateWaitTask).Unwrap().ConfigureAwait(false);
var updateMessage = MessageFactory.Text(update.Message);
// refresh incremental update wait task
updateWaitTask = WaitSentenceUpdate();
// Cache the value of task completion status.
generateComplete = generateTask.IsCompleted;
// If it's the first update there's no activity id generated yet.
if (string.IsNullOrEmpty(answerId))
{
var response = await turnContext.SendActivityAsync(updateMessage, cancellationToken).ConfigureAwait(false);
answerId = response.Id;
}
// For subsequent updates use the same activity id.
else
{
if (generateComplete && !isChannel)
{
// When generation is complete the message we've been updating is deleted, and then the entire content is send as a new message.
// This raises a notification to the user when letter is complete,
// and serves as a workaround to `UpdateActivity` not cancelling typing indicator.
await Task.WhenAll(turnContext.DeleteActivityAsync(answerId, cancellationToken),
turnContext.SendActivityAsync(updateMessage, cancellationToken)).ConfigureAwait(false);
}
else
{
// If generation is not complete use the same activity id and update the message.
updateMessage.Id = answerId;
await turnContext.UpdateActivityAsync(updateMessage, cancellationToken).ConfigureAwait(false);
}
}
// refresh typing indicator if still generating or bot is busy
if ((!generateComplete || update.Type == ConversationResponseType.Busy) && !isChannel)
{
// Typing indicator is reset when `SendActivity` is called, so it has to be resend.
await turnContext.SendActivityAsync(new Activity { Type = ActivityTypes.Typing }, cancellationToken).ConfigureAwait(false);
}
} while (!generateComplete);
}
protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var adaptiveCardJson = File.ReadAllText(@".\Cards\welcomeCard.json");
JObject json = JObject.Parse(adaptiveCardJson);
var adaptiveCardAttachment = new Attachment()
{
ContentType = "application/vnd.microsoft.card.adaptive",
Content = JsonConvert.DeserializeObject(json.ToString()),
};
var response = MessageFactory.Attachment(adaptiveCardAttachment);
await turnContext.SendActivityAsync(response, cancellationToken).ConfigureAwait(false);
}
private async Task<ConversationResponse> WaitSentenceUpdate(bool withDelay = false)
{
var task = _sentenceUpdate.Task;
if (withDelay)
{
await Task.WhenAll(task, Task.Delay(UPDATE_INITIAL_DELAY_SECS)).ConfigureAwait(false);
}
else
{
await task.ConfigureAwait(false);
}
return new ConversationResponse(task.Result, ConversationResponseType.Chat);
}
private void SentenceUpdateCallback(string message)
{
_sentenceUpdate.TrySetResult(message);
// Replace the incremental update task source with a new instance so that we can receive further updates via the event handler.
_sentenceUpdate = new TaskCompletionSource<string>();
}
}
} | NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Bots/Bot.cs | microsoft-NonprofitVirtualAssistant-be69e9b | [
{
"filename": "NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Services/ConversationManager.cs",
"retrieved_chunk": "{\n public class ConversationManager\n {\n private const string CONVERSATION_STORE_KEY = \"conversations\";\n private const int CHAR_LIMIT = 800;\n private static readonly char[] END_CHARS = new[] { '.', '\\n' };\n private const string MODERATION_MESSAGE = \"Warning: your message has been flagged for a possible content violation. Please rephrase your response and try again. Repeated violations may result in a suspension of this service.\";\n private const string WAIT_MESSAGE = \"The bot is currently working. Please wait until the bot has responded before sending a new message.\";\n private const string RATE_LIMIT_MESSAGE = \"Rate limit reached for OpenAI api. Please wait a while and try again.\";\n private static readonly string[] CHAR_LIMIT_WARNINGS = new[] {",
"score": 0.8578566312789917
},
{
"filename": "NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Services/OpenAIService.cs",
"retrieved_chunk": " private const string OPENAI_CONFIG_KEY = \"OPENAI_KEY\";\n private const string OPENAI_CONFIG_MODERATION_ENDPOINT = \"OPENAI_MODERATION_ENDPOINT\";\n private const string GPT_MODEL_NAME = \"gpt-4\";\n private const int MAX_PROMPT_LENGTH = 3000 * 4; // one token is roughly 4 characters\n private readonly OpenAIClient _client;\n private readonly RequestUriBuilder _moderationEndpoint;\n public OpenAIService(IConfiguration configuration)\n {\n // make the retry policy more relaxed\n var options = new OpenAIClientOptions();",
"score": 0.8547453284263611
},
{
"filename": "NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Models/ConversationResponse.cs",
"retrieved_chunk": "using NVA.Enums;\nnamespace NVA.Models\n{\n public class ConversationResponse\n {\n public string Message { get; }\n public ConversationResponseType Type { get; }\n public bool IsError => Type != ConversationResponseType.Chat;\n public ConversationResponse(string message, ConversationResponseType type)\n {",
"score": 0.8415076732635498
},
{
"filename": "NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Models/ModerationResponse.cs",
"retrieved_chunk": "namespace NVA.Models\n{\n // Moderation result has more fields for detailed categorization of response which are not included here\n public class ModerationResult\n {\n public bool Flagged { get; set; }\n }\n public class ModerationResponse\n {\n public string Id { get; set; }",
"score": 0.8194612860679626
},
{
"filename": "NonprofitVirtualAssistant/csharp/NonprofitVirtualAssistant/Models/MessagePair.cs",
"retrieved_chunk": "using Azure.AI.OpenAI;\nusing System.Diagnostics;\nnamespace NVA.Models\n{\n public class MessagePair\n {\n public ChatMessage User { get; }\n public ChatMessage Assistant { get; }\n public MessagePair(ChatMessage user, ChatMessage assistant)\n {",
"score": 0.8095476031303406
}
] | csharp | ConversationManager _conversationManager; |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace TreeifyTask
{
public class TaskNode : ITaskNode
{
private static Random rnd = new Random();
private readonly List<Task> taskObjects = new();
private readonly List<ITaskNode> childTasks = new();
private bool hasCustomAction;
private Func<IProgressReporter, CancellationToken, Task> action =
async (rep, tok) => await Task.Yield();
public event ProgressReportingEventHandler Reporting;
private bool seriesRunnerIsBusy;
private bool concurrentRunnerIsBusy;
public TaskNode()
{
this.Id = rnd.Next() + string.Empty;
this.Reporting += OnSelfReporting;
}
public TaskNode(string Id)
: this()
{
this.Id = Id ?? rnd.Next() + string.Empty;
}
public TaskNode(string Id, Func<IProgressReporter, CancellationToken, Task> cancellableProgressReportingAsyncFunction)
: this(Id)
{
this.SetAction(cancellableProgressReportingAsyncFunction);
}
#region Props
public string Id { get; set; }
public double ProgressValue { get; private set; }
public object ProgressState { get; private set; }
public TaskStatus TaskStatus { get; private set; }
public ITaskNode Parent { get; set; }
public IEnumerable<ITaskNode> ChildTasks =>
this.childTasks;
#endregion Props
public void AddChild(ITaskNode childTask)
{
childTask = childTask ?? throw new ArgumentNullException(nameof(childTask));
childTask.Parent = this;
// Ensure this after setting its parent as this
EnsureNoCycles(childTask);
childTask.Reporting += OnChildReporting;
childTasks.Add(childTask);
}
private class ActionReport
{
public ActionReport()
{
this.TaskStatus = TaskStatus.NotStarted;
this.ProgressValue = 0;
this.ProgressState = null;
}
public ActionReport(ITaskNode task)
{
this.Id = task.Id;
this.TaskStatus = task.TaskStatus;
this.ProgressState = task.ProgressState;
this.ProgressValue = task.ProgressValue;
}
public string Id { get; set; }
public TaskStatus TaskStatus { get; set; }
public double ProgressValue { get; set; }
public object ProgressState { get; set; }
public override string ToString()
{
return $"Id={Id},({TaskStatus}, {ProgressValue}, {ProgressState})";
}
}
private ActionReport selfActionReport = new();
private void OnSelfReporting(object sender, ProgressReportingEventArgs eventArgs)
{
TaskStatus = selfActionReport.TaskStatus = eventArgs.TaskStatus;
ProgressValue = selfActionReport.ProgressValue = eventArgs.ProgressValue;
ProgressState = selfActionReport.ProgressState = eventArgs.ProgressState;
}
private void OnChildReporting(object sender, ProgressReportingEventArgs eventArgs)
{
// Child task that reports
var cTask = sender as ITaskNode;
var allReports = childTasks.Select(t => new ActionReport(t));
if (hasCustomAction)
{
allReports = allReports.Append(selfActionReport);
}
this.TaskStatus = allReports.Any(v => v.TaskStatus == TaskStatus.InDeterminate) ? TaskStatus.InDeterminate : TaskStatus.InProgress;
this.TaskStatus = allReports.Any(v => v.TaskStatus == TaskStatus.Failed) ? TaskStatus.Failed : this.TaskStatus;
if (this.TaskStatus == TaskStatus.Failed)
{
this.ProgressState = new AggregateException($"{Id}: One or more error occurred in child tasks.",
childTasks.Where(v => v.TaskStatus == TaskStatus.Failed && v.ProgressState is Exception)
.Select(c => c.ProgressState as Exception));
}
this.ProgressValue = allReports.Select(t => t.ProgressValue).Average();
SafeRaiseReportingEvent(this, new ProgressReportingEventArgs
{
ProgressValue = this.ProgressValue,
TaskStatus = this.TaskStatus,
ChildTasksRunningInParallel = concurrentRunnerIsBusy,
ProgressState = seriesRunnerIsBusy ? cTask.ProgressState : this.ProgressState
});
}
public async Task ExecuteConcurrently(CancellationToken cancellationToken, bool throwOnError)
{
if (concurrentRunnerIsBusy || seriesRunnerIsBusy) return;
concurrentRunnerIsBusy = true;
ResetChildrenProgressValues();
foreach (var child in childTasks)
{
taskObjects.Add(child.ExecuteConcurrently(cancellationToken, throwOnError));
}
taskObjects.Add(ExceptionHandledAction(cancellationToken, throwOnError));
if (taskObjects.Any())
{
await Task.WhenAll(taskObjects);
}
if (throwOnError && taskObjects.Any(t => t.IsFaulted))
{
var exs = taskObjects.Where(t => t.IsFaulted).Select(t => t.Exception);
throw new AggregateException($"Internal error occurred while executing task - {Id}.", exs);
}
concurrentRunnerIsBusy = false;
if (TaskStatus != TaskStatus.Failed)
{
if (cancellationToken.IsCancellationRequested)
Report(TaskStatus.Cancelled, 0);
else
Report(TaskStatus.Completed, 100);
}
}
private async Task ExceptionHandledAction(CancellationToken cancellationToken, bool throwOnError)
{
try
{
await action(this, cancellationToken);
}
catch (OperationCanceledException)
{
// Don't throw this as an error as we have to come out of await.
}
catch (Exception ex)
{
this.Report(TaskStatus.Failed, this.ProgressValue, ex);
if (throwOnError)
{
throw new AggregateException($"Internal error occurred while executing the action of task - {Id}.", ex);
}
}
}
public async Task ExecuteInSeries(CancellationToken cancellationToken, bool throwOnError)
{
if (seriesRunnerIsBusy || concurrentRunnerIsBusy) return;
seriesRunnerIsBusy = true;
ResetChildrenProgressValues();
try
{
foreach (var child in childTasks)
{
if (cancellationToken.IsCancellationRequested) break;
await child.ExecuteInSeries(cancellationToken, throwOnError);
}
await ExceptionHandledAction(cancellationToken, throwOnError);
}
catch (Exception ex)
{
if (throwOnError)
{
throw new AggregateException($"Internal error occurred while executing task - {Id}.", ex);
}
}
seriesRunnerIsBusy = false;
if (TaskStatus != TaskStatus.Failed)
{
if (cancellationToken.IsCancellationRequested)
Report(TaskStatus.Cancelled, 0);
else
Report(TaskStatus.Completed, 100);
}
}
public IEnumerable<ITaskNode> ToFlatList()
{
return FlatList(this);
}
private void SafeRaiseReportingEvent(object sender, | ProgressReportingEventArgs args)
{ |
this.Reporting?.Invoke(sender, args);
}
private void ResetChildrenProgressValues()
{
taskObjects.Clear();
foreach (var task in childTasks)
{
task.ResetStatus();
}
}
/// <summary>
/// Throws <see cref="AsyncTasksCycleDetectedException"/>
/// </summary>
/// <param name="newTask"></param>
private void EnsureNoCycles(ITaskNode newTask)
{
var thisNode = this as ITaskNode;
HashSet<ITaskNode> hSet = new HashSet<ITaskNode>();
while (true)
{
if (thisNode.Parent is null)
{
break;
}
if (hSet.Contains(thisNode))
{
throw new TaskNodeCycleDetectedException(thisNode, newTask);
}
hSet.Add(thisNode);
thisNode = thisNode.Parent;
}
var existingTask = FlatList(thisNode).FirstOrDefault(t => t == newTask);
if (existingTask != null)
{
throw new TaskNodeCycleDetectedException(newTask, existingTask.Parent);
}
}
private IEnumerable<ITaskNode> FlatList(ITaskNode root)
{
yield return root;
foreach (var ct in root.ChildTasks)
{
foreach (var item in FlatList(ct))
yield return item;
}
}
public void RemoveChild(ITaskNode childTask)
{
childTask.Reporting -= OnChildReporting;
childTasks.Remove(childTask);
}
public void Report(TaskStatus taskStatus, double progressValue, object progressState = null)
{
SafeRaiseReportingEvent(this, new ProgressReportingEventArgs
{
ChildTasksRunningInParallel = concurrentRunnerIsBusy,
TaskStatus = taskStatus,
ProgressValue = progressValue,
ProgressState = progressState
});
}
public void SetAction(Func<IProgressReporter, CancellationToken, Task> cancellableProgressReportingAction)
{
cancellableProgressReportingAction = cancellableProgressReportingAction ??
throw new ArgumentNullException(nameof(cancellableProgressReportingAction));
hasCustomAction = true;
action = cancellableProgressReportingAction;
}
public void ResetStatus()
{
this.TaskStatus = TaskStatus.NotStarted;
this.ProgressState = null;
this.ProgressValue = 0;
}
public override string ToString()
{
return $"Id={Id},({TaskStatus}, {ProgressValue}, {ProgressState})";
}
}
}
| Source/TreeifyTask/TaskTree/TaskNode.cs | intuit-TreeifyTask-4b124d4 | [
{
"filename": "Source/TreeifyTask/TaskTree/IProgressReporter.cs",
"retrieved_chunk": "namespace TreeifyTask\n{\n public interface IProgressReporter\n {\n void Report(TaskStatus taskStatus, double progressValue, object progressState = default);\n event ProgressReportingEventHandler Reporting;\n }\n}",
"score": 0.8596479892730713
},
{
"filename": "Source/TreeifyTask.WpfSample/TaskNodeViewModel.cs",
"retrieved_chunk": " {\n this._childTasks.Add(new TaskNodeViewModel(ct));\n }\n }\n private void BaseTaskNode_Reporting(object sender, ProgressReportingEventArgs eventArgs)\n {\n this.TaskStatus = eventArgs.TaskStatus;\n }\n public ObservableCollection<TaskNodeViewModel> ChildTasks =>\n _childTasks;",
"score": 0.8593950271606445
},
{
"filename": "Source/TreeifyTask.WpfSample/MainWindow.xaml.cs",
"retrieved_chunk": " }\n if (!error && !token.IsCancellationRequested)\n {\n progressReporter.Report(TaskStatus.Completed, 100, $\"{progressMessage}: 100%\");\n }\n }\n CancellationTokenSource tokenSource;\n private async void StartClick(object sender, RoutedEventArgs e)\n {\n grpExecutionMethod.IsEnabled = false;",
"score": 0.8228437900543213
},
{
"filename": "Source/TreeifyTask.BlazorSample/TaskDataModel/code.cs",
"retrieved_chunk": " }\n private Task Task1_2(Pr reporter, Tk token)\n {\n throw new NotImplementedException();\n }\n }\n}",
"score": 0.8147939443588257
},
{
"filename": "Source/TreeifyTask.BlazorSample/TaskDataModel/code.cs",
"retrieved_chunk": " {\n throw new NotImplementedException();\n }\n private Task Task4(Pr reporter, Tk token)\n {\n throw new NotImplementedException();\n }\n private Task Task3(Pr reporter, Tk token)\n {\n throw new NotImplementedException();",
"score": 0.8089232444763184
}
] | csharp | ProgressReportingEventArgs args)
{ |
#nullable disable
using System;
using System.Text;
using System.Collections.Generic;
using System.Net.Http;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Extensions;
using osu.Framework.Logging;
using osu.Game.Beatmaps;
using osu.Game.Overlays;
using osu.Game.Screens.Play;
using osu.Game.Rulesets.Gengo.Cards;
using osu.Game.Rulesets.Gengo.Configuration;
using osu.Game.Rulesets.Gengo.UI;
using Newtonsoft.Json;
using Microsoft.CSharp.RuntimeBinder;
namespace osu.Game.Rulesets.Gengo.Anki
{
/// <summary>
/// Class for connecting to the anki API.
/// </summary>
public partial class AnkiAPI : Component {
public string URL { get; set; }
public string ankiDeck{ get; set; }
public string foreignWordField { get; set; }
public string translatedWordField { get; set; }
private List< | Card> dueCards = new List<Card>(); |
private HttpClient httpClient;
[Resolved]
protected GengoRulesetConfigManager config { get; set; }
[Resolved]
protected IBeatmap beatmap { get; set; }
[Resolved]
protected IDialogOverlay dialogOverlay { get; set; }
private Random hitObjectRandom;
/// <summary>
/// Function checks whether it's possible to send valid requests to the Anki API with current configurations
/// </summary>
bool CheckSettings() {
var requestData = new {
action = "findCards",
version = 6,
parameters = new {
query = $"deck:\"{ankiDeck}\" is:due"
}
};
try {
var jsonRequestData = new StringContent(JsonConvert.SerializeObject(requestData));
var response = httpClient.PostAsync(URL, jsonRequestData).GetResultSafely();
response.EnsureSuccessStatusCode();
var responseString = response.Content.ReadAsStringAsync().GetResultSafely();
var deserializedResponse = JsonConvert.DeserializeObject<dynamic>(responseString);
return deserializedResponse.error == null;
} catch {
return false;
}
}
[BackgroundDependencyLoader]
public void load() {
URL = config?.GetBindable<string>(GengoRulesetSetting.AnkiURL).Value;
ankiDeck = config?.GetBindable<string>(GengoRulesetSetting.DeckName).Value;
foreignWordField = config?.GetBindable<string>(GengoRulesetSetting.ForeignWord).Value;
translatedWordField = config?.GetBindable<string>(GengoRulesetSetting.TranslatedWord).Value;
httpClient = new HttpClient();
// convert from string -> bytes -> int32
int beatmapHash = BitConverter.ToInt32(Encoding.UTF8.GetBytes(beatmap.BeatmapInfo.Hash), 0);
hitObjectRandom = new Random(beatmapHash);
if(!CheckSettings()) {
dialogOverlay.Push(new AnkiConfigurationDialog("It seems like you've misconfigured osu!gengo's settings", "Back to the settings I go.."));
} else {
GetDueCardsFull();
}
}
/// <summary>
/// Function to fetch due cards from the Anki API
/// </summary>
public void GetDueCardsFull() {
// IDEA: Make the query customizable in the future (i.e. add a settings option for it)
var requestData = new {
action = "findCardsFull",
version = 6,
parameters = new {
query = $"deck:\"{ankiDeck}\" is:due",
},
};
var jsonRequestData = new StringContent(JsonConvert.SerializeObject(requestData));
var response = httpClient.PostAsync(URL, jsonRequestData).GetResultSafely();
var responseString = response.Content.ReadAsStringAsync().GetResultSafely();
dynamic deserializedResponse = JsonConvert.DeserializeObject<dynamic>(responseString);
// If there's an error with the Anki query, create an error dialog
if (deserializedResponse.error != null) {
dialogOverlay.Push(new AnkiConfigurationDialog($"Error retrieved from the Anki API: {deserializedResponse.error}", "Go back"));
return;
}
// Try to fill the cards array. If you get a null-reference, it means that the field names configured by the user are wrong
try {
foreach (var id in deserializedResponse.result) {
string foreignWord = id.fields[foreignWordField].value;
string translatedWord = id.fields[translatedWordField].value;
string cardId = id.cardId;
var newCard = new Card(foreignWord, translatedWord, cardId.ToString());
dueCards.Add(newCard);
}
}
catch (RuntimeBinderException) {
dialogOverlay.Push(new AnkiConfigurationDialog($"Double check if the field names ('{foreignWordField}', '{translatedWordField}') are correct for the cards used in the deck '{ankiDeck}'", "Go back"));
return;
}
// If there's no cards in the array, create an error dialog
if (dueCards.Count == 0) {
dialogOverlay.Push(new AnkiConfigurationDialog($"No due cards found in deck '{ankiDeck}' at '{URL}'", "Go back"));
return;
}
}
/// <summary>
/// Return random card object from <see cref="dueCards"/>
/// </summary>
public Card FetchRandomCard() {
if (dueCards.Count <= 0) {
return new Card("NULL", "NULL", "NULL");
}
int randomIndex = hitObjectRandom.Next(0, dueCards.Count);
return dueCards[randomIndex];
}
}
} | osu.Game.Rulesets.Gengo/Anki/Anki.cs | 0xdeadbeer-gengo-dd4f78d | [
{
"filename": "osu.Game.Rulesets.Gengo/Cards/Card.cs",
"retrieved_chunk": "using System;\nnamespace osu.Game.Rulesets.Gengo.Cards \n{\n public class Card : IEquatable<Card> {\n public string foreignText { get; set; }\n public string translatedText { get; set; }\n public string cardID { get; set; }\n public Card(string foreignText, string translatedText, string cardID) {\n this.foreignText = foreignText;\n this.translatedText = translatedText;",
"score": 0.8790489435195923
},
{
"filename": "osu.Game.Rulesets.Gengo/Objects/Drawables/DrawableGengoHitObject.cs",
"retrieved_chunk": " }\n [Resolved]\n protected TranslationContainer translationContainer { get; set; }\n [Resolved]\n protected AnkiAPI anki { get; set; }\n private Card assignedCard;\n private Card baitCard;\n private Box cardDesign;\n private OsuSpriteText cardText;\n [BackgroundDependencyLoader]",
"score": 0.8779645562171936
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/GengoPlayfieldAdjustmentContainer.cs",
"retrieved_chunk": " }\n /// <summary>\n /// A <see cref=\"Container\"/> which scales its content relative to a target width.\n /// </summary>\n private partial class ScalingContainer : Container\n {\n internal bool PlayfieldShift { get; set; }\n protected override void Update()\n {\n base.Update();",
"score": 0.8565548658370972
},
{
"filename": "osu.Game.Rulesets.Gengo/UI/Cursor/GengoCursorContainer.cs",
"retrieved_chunk": " private Bindable<bool> autoCursorScale;\n [Resolved(canBeNull: true)]\n private GameplayState state { get; set; }\n [Resolved]\n private OsuConfigManager config { get; set; }\n protected override Drawable CreateCursor() => new GengoCursor();\n [BackgroundDependencyLoader]\n private void load(TextureStore textures) {\n }\n protected override void LoadComplete()",
"score": 0.831699013710022
},
{
"filename": "osu.Game.Rulesets.Gengo/Cards/Card.cs",
"retrieved_chunk": " this.cardID = cardID;\n }\n public override bool Equals(object? obj)\n {\n return this.Equals(obj as Card);\n }\n public override int GetHashCode()\n {\n int hash = 0; \n hash += 31 * foreignText?.GetHashCode() ?? 0;",
"score": 0.812930703163147
}
] | csharp | Card> dueCards = new List<Card>(); |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace csharp_test_client
{
public partial class mainForm : Form
{
ClientSimpleTcp Network = new ClientSimpleTcp();
bool IsNetworkThreadRunning = false;
bool IsBackGroundProcessRunning = false;
System.Threading.Thread NetworkReadThread = null;
System.Threading.Thread NetworkSendThread = null;
| PacketBufferManager PacketBuffer = new PacketBufferManager(); |
Queue<PacketData> RecvPacketQueue = new Queue<PacketData>();
Queue<byte[]> SendPacketQueue = new Queue<byte[]>();
System.Windows.Threading.DispatcherTimer dispatcherUITimer;
public mainForm()
{
InitializeComponent();
}
private void mainForm_Load(object sender, EventArgs e)
{
PacketBuffer.Init((8096 * 10), PacketDef.PACKET_HEADER_SIZE, 1024);
IsNetworkThreadRunning = true;
NetworkReadThread = new System.Threading.Thread(this.NetworkReadProcess);
NetworkReadThread.Start();
NetworkSendThread = new System.Threading.Thread(this.NetworkSendProcess);
NetworkSendThread.Start();
IsBackGroundProcessRunning = true;
dispatcherUITimer = new System.Windows.Threading.DispatcherTimer();
dispatcherUITimer.Tick += new EventHandler(BackGroundProcess);
dispatcherUITimer.Interval = new TimeSpan(0, 0, 0, 0, 100);
dispatcherUITimer.Start();
btnDisconnect.Enabled = false;
SetPacketHandler();
DevLog.Write("프로그램 시작 !!!", LOG_LEVEL.INFO);
}
private void mainForm_FormClosing(object sender, FormClosingEventArgs e)
{
IsNetworkThreadRunning = false;
IsBackGroundProcessRunning = false;
Network.Close();
}
private void btnConnect_Click(object sender, EventArgs e)
{
string address = textBoxIP.Text;
if (checkBoxLocalHostIP.Checked)
{
address = "127.0.0.1";
}
int port = Convert.ToInt32(textBoxPort.Text);
if (Network.Connect(address, port))
{
labelStatus.Text = string.Format("{0}. 서버에 접속 중", DateTime.Now);
btnConnect.Enabled = false;
btnDisconnect.Enabled = true;
DevLog.Write($"서버에 접속 중", LOG_LEVEL.INFO);
}
else
{
labelStatus.Text = string.Format("{0}. 서버에 접속 실패", DateTime.Now);
}
}
private void btnDisconnect_Click(object sender, EventArgs e)
{
SetDisconnectd();
Network.Close();
}
private void button1_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(textSendText.Text))
{
MessageBox.Show("보낼 텍스트를 입력하세요");
return;
}
var body = Encoding.UTF8.GetBytes(textSendText.Text);
List<byte> dataSource = new List<byte>();
dataSource.AddRange(BitConverter.GetBytes((UInt16)(body.Length + PacketDef.PACKET_HEADER_SIZE)));
dataSource.AddRange(BitConverter.GetBytes((UInt16)PACKET_ID.DEV_ECHO));
dataSource.AddRange(new byte[] { (byte)0 });
dataSource.AddRange(body);
SendPacketQueue.Enqueue(dataSource.ToArray());
}
void NetworkReadProcess()
{
const Int16 PacketHeaderSize = PacketDef.PACKET_HEADER_SIZE;
while (IsNetworkThreadRunning)
{
if (Network.IsConnected() == false)
{
System.Threading.Thread.Sleep(1);
continue;
}
var recvData = Network.Receive();
if (recvData != null)
{
PacketBuffer.Write(recvData.Item2, 0, recvData.Item1);
while (true)
{
var data = PacketBuffer.Read();
if (data.Count < 1)
{
break;
}
var packet = new PacketData();
packet.DataSize = (short)(data.Count - PacketHeaderSize);
packet.PacketID = BitConverter.ToInt16(data.Array, data.Offset + 2);
packet.Type = (SByte)data.Array[(data.Offset + 4)];
packet.BodyData = new byte[packet.DataSize];
Buffer.BlockCopy(data.Array, (data.Offset + PacketHeaderSize), packet.BodyData, 0, (data.Count - PacketHeaderSize));
lock (((System.Collections.ICollection)RecvPacketQueue).SyncRoot)
{
RecvPacketQueue.Enqueue(packet);
}
}
DevLog.Write($"받은 데이터 크기: {recvData.Item1}", LOG_LEVEL.INFO);
}
else
{
Network.Close();
SetDisconnectd();
DevLog.Write("서버와 접속 종료 !!!", LOG_LEVEL.INFO);
}
}
}
void NetworkSendProcess()
{
while (IsNetworkThreadRunning)
{
System.Threading.Thread.Sleep(1);
if (Network.IsConnected() == false)
{
continue;
}
lock (((System.Collections.ICollection)SendPacketQueue).SyncRoot)
{
if (SendPacketQueue.Count > 0)
{
var packet = SendPacketQueue.Dequeue();
Network.Send(packet);
}
}
}
}
void BackGroundProcess(object sender, EventArgs e)
{
ProcessLog();
try
{
var packet = new PacketData();
lock (((System.Collections.ICollection)RecvPacketQueue).SyncRoot)
{
if (RecvPacketQueue.Count() > 0)
{
packet = RecvPacketQueue.Dequeue();
}
}
if (packet.PacketID != 0)
{
PacketProcess(packet);
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("ReadPacketQueueProcess. error:{0}", ex.Message));
}
}
private void ProcessLog()
{
// 너무 이 작업만 할 수 없으므로 일정 작업 이상을 하면 일단 패스한다.
int logWorkCount = 0;
while (IsBackGroundProcessRunning)
{
System.Threading.Thread.Sleep(1);
string msg;
if (DevLog.GetLog(out msg))
{
++logWorkCount;
if (listBoxLog.Items.Count > 512)
{
listBoxLog.Items.Clear();
}
listBoxLog.Items.Add(msg);
listBoxLog.SelectedIndex = listBoxLog.Items.Count - 1;
}
else
{
break;
}
if (logWorkCount > 8)
{
break;
}
}
}
public void SetDisconnectd()
{
if (btnConnect.Enabled == false)
{
btnConnect.Enabled = true;
btnDisconnect.Enabled = false;
}
SendPacketQueue.Clear();
listBoxRoomChatMsg.Items.Clear();
listBoxRoomUserList.Items.Clear();
labelStatus.Text = "서버 접속이 끊어짐";
}
public void PostSendPacket(PACKET_ID packetID, byte[] bodyData)
{
if (Network.IsConnected() == false)
{
DevLog.Write("서버 연결이 되어 있지 않습니다", LOG_LEVEL.ERROR);
return;
}
Int16 bodyDataSize = 0;
if (bodyData != null)
{
bodyDataSize = (Int16)bodyData.Length;
}
var packetSize = bodyDataSize + PacketDef.PACKET_HEADER_SIZE;
List<byte> dataSource = new List<byte>();
dataSource.AddRange(BitConverter.GetBytes((UInt16)packetSize));
dataSource.AddRange(BitConverter.GetBytes((UInt16)packetID));
dataSource.AddRange(new byte[] { (byte)0 });
if (bodyData != null)
{
dataSource.AddRange(bodyData);
}
SendPacketQueue.Enqueue(dataSource.ToArray());
}
void AddRoomUserList(Int64 userUniqueId, string userID)
{
var msg = $"{userUniqueId}: {userID}";
listBoxRoomUserList.Items.Add(msg);
}
void RemoveRoomUserList(Int64 userUniqueId)
{
object removeItem = null;
foreach( var user in listBoxRoomUserList.Items)
{
var items = user.ToString().Split(":");
if( items[0].ToInt64() == userUniqueId)
{
removeItem = user;
return;
}
}
if (removeItem != null)
{
listBoxRoomUserList.Items.Remove(removeItem);
}
}
// 로그인 요청
private void button2_Click(object sender, EventArgs e)
{
var loginReq = new LoginReqPacket();
loginReq.SetValue(textBoxUserID.Text, textBoxUserPW.Text);
PostSendPacket(PACKET_ID.LOGIN_REQ, loginReq.ToBytes());
DevLog.Write($"로그인 요청: {textBoxUserID.Text}, {textBoxUserPW.Text}");
}
private void btn_RoomEnter_Click(object sender, EventArgs e)
{
var requestPkt = new RoomEnterReqPacket();
requestPkt.SetValue(textBoxRoomNumber.Text.ToInt32());
PostSendPacket(PACKET_ID.ROOM_ENTER_REQ, requestPkt.ToBytes());
DevLog.Write($"방 입장 요청: {textBoxRoomNumber.Text} 번");
}
private void btn_RoomLeave_Click(object sender, EventArgs e)
{
PostSendPacket(PACKET_ID.ROOM_LEAVE_REQ, null);
DevLog.Write($"방 입장 요청: {textBoxRoomNumber.Text} 번");
}
private void btnRoomChat_Click(object sender, EventArgs e)
{
if(textBoxRoomSendMsg.Text.IsEmpty())
{
MessageBox.Show("채팅 메시지를 입력하세요");
return;
}
var requestPkt = new RoomChatReqPacket();
requestPkt.SetValue(textBoxRoomSendMsg.Text);
PostSendPacket(PACKET_ID.ROOM_CHAT_REQ, requestPkt.ToBytes());
DevLog.Write($"방 채팅 요청");
}
private void btnRoomRelay_Click(object sender, EventArgs e)
{
//if( textBoxRelay.Text.IsEmpty())
//{
// MessageBox.Show("릴레이 할 데이터가 없습니다");
// return;
//}
//var bodyData = Encoding.UTF8.GetBytes(textBoxRelay.Text);
//PostSendPacket(PACKET_ID.PACKET_ID_ROOM_RELAY_REQ, bodyData);
//DevLog.Write($"방 릴레이 요청");
}
// 로그인서버에 로그인 요청하기
private async void button3_Click(object sender, EventArgs e)
{
var client = new HttpClient();
var loginJson = new LoginReqJson { userID = textBox2.Text, userPW = "hhh" };
var json = Utf8Json.JsonSerializer.ToJsonString(loginJson);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(textBox1.Text, content);
var responseStream = await response.Content.ReadAsByteArrayAsync();//await response.Content.ReadAsStringAsync();
var loginRes = Utf8Json.JsonSerializer.Deserialize<LoginResJson>(responseStream);
if (loginRes.result == 1)
{
textBoxIP.Text = loginRes.gameServerIP;
textBoxPort.Text = loginRes.gameServerPort.ToString();
textBoxUserID.Text = textBox2.Text;
textBoxUserPW.Text = loginRes.authToken;
DevLog.Write($"[성공] LoginServer에 로그인 요청");
}
else
{
DevLog.Write($"[실패] LoginServer에 로그인 요청 !!!");
}
}
}
}
| cpp/Demo_2020-02-15/Client/mainForm.cs | jacking75-how_to_use_redis_lib-d3accba | [
{
"filename": "csharp/redisTest/mainForm.cs",
"retrieved_chunk": "using System.Threading.Tasks;\nusing System.Windows.Forms;\nnamespace csharp_test_client\n{\n public partial class mainForm : Form\n {\n bool IsBackGroundProcessRunning = false;\n System.Windows.Forms.Timer dispatcherUITimer = new();\n public mainForm()\n {",
"score": 0.8580855131149292
},
{
"filename": "cpp/Demo_2020-02-15/Client/ClientSimpleTcp.cs",
"retrieved_chunk": "using System;\nusing System.Net.Sockets;\nusing System.Net;\nnamespace csharp_test_client\n{\n public class ClientSimpleTcp\n {\n public Socket Sock = null; \n public string LatestErrorMsg;\n //소켓연결 ",
"score": 0.8280975818634033
},
{
"filename": "cpp/Demo_2020-02-15/APIServer/LoginServer.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nnamespace APIServer\n{\n public class LoginServer\n {\n public static ServerOption ServerOpt;\n static public void Init(string[] args)",
"score": 0.8248763084411621
},
{
"filename": "cpp/Demo_2020-02-15/APIServer/Program.cs",
"retrieved_chunk": "{\n public class Program\n {\n public static void Main(string[] args)\n {\n LoginServer.Init(args);\n BuildWebHost(args).Run();\n }\n public static IWebHost BuildWebHost(string[] args) =>\n WebHost.CreateDefaultBuilder(args)",
"score": 0.796322226524353
},
{
"filename": "cpp/Demo_2020-02-15/Client/PacketBufferManager.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\nnamespace csharp_test_client\n{\n class PacketBufferManager\n {\n int BufferSize = 0;",
"score": 0.7877938747406006
}
] | csharp | PacketBufferManager PacketBuffer = new PacketBufferManager(); |
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine;
namespace ZimGui.Core {
[StructLayout(LayoutKind.Sequential)]
public struct Options {
public byte Size;
public byte Padding0; //TODO use paddings for something like bold style.
public byte Padding1;
public byte Padding2;
}
[StructLayout(LayoutKind.Sequential)]
public struct VertexData {
/// <summary>
/// Screen Position
/// </summary>
public Vector2 Position;
public UiColor Color;
public Vector2 UV;
public Options Options;
public void Write(Vector2 position, byte scale, UiColor color, Vector2 uv) {
Position = position;
Color = color;
UV = uv;
Options.Size = scale;
}
[MethodImpl((MethodImplOptions) 256)]
public void Write(Vector2 position, Vector2 uv) {
Position = position;
UV = uv;
}
[MethodImpl((MethodImplOptions) 256)]
public void Write(float positionX, float positionY, Vector2 uv) {
Position.x = positionX;
Position.y = positionY;
UV = uv;
}
[MethodImpl((MethodImplOptions) 256)]
public void Write(float positionX, float positionY, float u, float v) {
Position.x = positionX;
Position.y = positionY;
UV.x = u;
UV.y = v;
}
public void Write(Vector2 position, byte scale, UiColor color, float uvX, float uvY) {
Position = position;
Color = color;
UV = new Vector2(uvX, uvY);
Options.Size = scale;
}
public void Write(float x, float y, byte scale, UiColor color, float uvX, float uvY) {
Position.x = x;
Position.y = y;
Color = color;
UV = new Vector2(uvX, uvY);
Options.Size = scale;
}
public void Write(Vector2 position, float uvX, float uvY) {
Position = position;
UV.x = uvX;
UV.y = uvY;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct Quad {
/// <summary>
/// Top Left
/// </summary>
public VertexData V0;
/// <summary>
/// Top Right
/// </summary>
public VertexData V1;
/// <summary>
/// Bottom Right
/// </summary>
public VertexData V2;
/// <summary>
/// Bottom Left
/// </summary>
public VertexData V3;
public void WriteLine(Vector2 start, Vector2 end, float width, UiColor color, Vector2 quadUV) {
V3.Color = V2.Color = V1.Color = V0.Color = color;
V3.UV = V2.UV = V1.UV = V0.UV = quadUV;
V3.Options.Size = V2.Options.Size = V1.Options.Size = V0.Options.Size = 255;
var p = (end - start).Perpendicular();
var verticalX = p.x * width / 2;
var verticalY = p.y * width / 2;
V0.Position.x = start.x + verticalX;
V0.Position.y = start.y + verticalY;
V1.Position.x = end.x + verticalX;
V1.Position.y = end.y + verticalY;
V2.Position.x = end.x - verticalX;
V2.Position.y = end.y - verticalY;
V3.Position.x = start.x - verticalX;
V3.Position.y = start.y - verticalY;
}
public void WriteLine(Vector2 start, Vector2 end, float width, UiColor startColor, UiColor endColor,
Vector2 quadUV) {
V3.UV = V2.UV = V1.UV = V0.UV = quadUV;
V3.Options.Size = V2.Options.Size = V1.Options.Size = V0.Options.Size = 255;
V3.Color = V0.Color = startColor;
V2.Color = V1.Color = endColor;
var p = (end - start).Perpendicular();
var verticalX = p.x * width / 2;
var verticalY = p.y * width / 2;
V0.Position.x = start.x + verticalX;
V0.Position.y = start.y + verticalY;
V1.Position.x = end.x + verticalX;
V1.Position.y = end.y + verticalY;
V2.Position.x = end.x - verticalX;
V2.Position.y = end.y - verticalY;
V3.Position.x = start.x - verticalX;
V3.Position.y = start.y - verticalY;
}
public void WriteLinePosition(Vector2 start, Vector2 end, float width) {
var p = (end - start).Perpendicular();
var verticalX = p.x * width / 2;
var verticalY = p.y * width / 2;
V0.Position.x = start.x + verticalX;
V0.Position.y = start.y + verticalY;
V1.Position.x = end.x + verticalX;
V1.Position.y = end.y + verticalY;
V2.Position.x = end.x - verticalX;
V2.Position.y = end.y - verticalY;
V3.Position.x = start.x - verticalX;
V3.Position.y = start.y - verticalY;
}
public void WriteCircle(Vector2 center, float radius, UiColor color, in Vector4 circleUV) {
V3.Options.Size = V2.Options.Size = V1.Options.Size = V0.Options.Size = radius < 85 ? (byte) (radius * 3) : (byte) 255;
V3.Color = V2.Color = V1.Color = V0.Color = color;
V3.Position.x = V0.Position.x = center.x - radius;
V1.Position.y = V0.Position.y = center.y + radius;
V2.Position.x = V1.Position.x = center.x + radius;
V3.Position.y = V2.Position.y = center.y - radius;
V3.UV.x = V0.UV.x = circleUV.z;
V1.UV.y = V0.UV.y = circleUV.w + circleUV.y;
V2.UV.x = V1.UV.x = circleUV.x + circleUV.z;
V3.UV.y = V2.UV.y = circleUV.w;
}
public void Write(float x, float y, Vector2 scale, float fontSize, in UiMesh.CharInfo info) {
var uv = info.UV;
V3.UV.x = V0.UV.x = uv.z;
V1.UV.y = V0.UV.y = uv.w + uv.y;
V2.UV.x = V1.UV.x = uv.x + uv.z;
V3.UV.y = V2.UV.y = uv.w;
x += fontSize * info.XOffset;
V3.Position.x = V0.Position.x = x;
V2.Position.x = V1.Position.x = x + uv.x * scale.x;
y += fontSize * info.YOffset;
V3.Position.y = V2.Position.y = y;
V1.Position.y = V0.Position.y = y + uv.y * scale.y;
}
/*
var uv = info.UV;
quad.V3.UV.x=quad.V0.UV.x = uv.z;
quad.V1.UV.y=quad.V0.UV.y = uv.w + uv.y;
quad.V2.UV.x=quad.V1.UV.x= uv.x + uv.z;
quad.V3.UV.y=quad.V2.UV.y= uv.w;
var x = nextX+= fontSize * info.XOffset;
var y = position.y+fontSize * info.YOffset;
quad.V3.Position.x=quad.V0.Position.x = x;
quad.V2.Position.x=quad.V1.Position.x= x + uv.x * scale.x;
quad.V3.Position.y=quad.V2.Position.y= y;
quad.V1.Position.y=quad.V0.Position.y = y + uv.y * scale.y;
*/
public void WriteCircle(float centerX, float centerY, float radius, UiColor color, in Vector4 circleUV) {
V0.Options.Size = radius < 85 ? (byte) (radius * 3) : (byte) 255;
V0.Position.x = centerX - radius;
V0.Position.y = centerY - radius;
V0.Color = color;
V0.UV.x = circleUV.z;
V0.UV.y = circleUV.w + circleUV.y;
V3 = V2 = V1 = V0;
V2.Position.x = V1.Position.x = centerX + radius;
V3.Position.y = V2.Position.y = centerY + radius;
V2.UV.x = V1.UV.x = circleUV.x + circleUV.z;
V3.UV.y = V2.UV.y = circleUV.w;
}
public void WriteCircle(float centerX, float centerY, float radius) {
V0.Position.x = centerX - radius;
V0.Position.y = centerY - radius;
V2.Position.x = V1.Position.x = centerX + radius;
V3.Position.y = V2.Position.y = centerY + radius;
}
public static void WriteWithOutUVScale(ref Quad quad, Vector2 scale, Vector2 position, UiColor color,
Vector4 uv) {
var size = (byte) Mathf.Clamp((int) (scale.x * 2), 0, 255);
quad.V0.Write(position + new Vector2(0, scale.y), size, color, uv.z, uv.w + uv.y);
quad.V1.Write(position + scale, size, color, new Vector2(uv.x + uv.z, uv.y + uv.w));
quad.V2.Write(position + new Vector2(scale.x, 0), size, color, uv.x + uv.z, uv.w);
quad.V3.Write(position, size, color, new Vector2(uv.z, uv.w));
}
public static void WriteWithOutUV(ref Quad quad, Vector2 scale, Vector2 position, UiColor color) {
quad.V0.Write(position + new Vector2(0, scale.y), 0, color, 0, 1);
quad.V1.Write(position + scale, 0, color, 1, 1);
quad.V2.Write(position + new Vector2(scale.x, 0), 0, color, 1, 0);
quad.V3.Write(position, 0, color, 0, 0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(float xMin, float xMax, float yMin, float yMax, ref Vector4 uv) {
V3.Position.x = V0.Position.x = xMin;
V3.UV.x = V0.UV.x = uv.z;
V1.Position.y = V0.Position.y = yMax;
V1.UV.y = V0.UV.y = uv.w + uv.y;
V2.Position.x = V1.Position.x = xMax;
V2.UV.x = V1.UV.x = uv.x + uv.z;
V3.Position.y = V2.Position.y = yMin;
V3.UV.y = V2.UV.y = uv.w;
}
public static void WriteHorizontalGradient(ref Quad quad, Vector2 scale, Vector2 position, UiColor leftColor,
| UiColor rightColor, Vector2 uv) { |
var size = (byte) Mathf.Clamp((int) scale.x, 0, 255);
quad.V0.Write(position + new Vector2(0, scale.y), size, leftColor, uv);
quad.V1.Write(position + scale, size, rightColor, uv);
quad.V2.Write(position + new Vector2(scale.x, 0), size, rightColor, uv);
quad.V3.Write(position, size, leftColor, uv);
}
public void MaskTextMaxX(float x) {
var u = V0.UV.x;
var minX = V0.Position.x;
u += (V1.UV.x - u) * (x - minX) / (V1.Position.x - minX);
V1.Position.x = x;
V1.UV.x = u;
V2.Position.x = x;
V2.UV.x = u;
}
public void MaskTextMaxY(float y) {
var maxY = V1.Position.y;
if (maxY < y) return;
var v = V0.UV.y;
var minY = V0.Position.x;
v += (V1.UV.y - v) * (y - minY) / (maxY - minY);
V1.Position.y = y;
V1.UV.y = v;
V2.Position.y = y;
V2.UV.y = v;
}
/// <summary>
/// /UseThisBefore WriteLinePositionOnly
/// </summary>
/// <param name="span"></param>
/// <param name="color"></param>
/// <param name="quadUV"></param>
public static unsafe void SetUpQuadColorUV(Span<Quad> span, UiColor color, Vector2 quadUV) {
fixed (Quad* p = span) {
*p = default;
p->SetColor(color);
p->SetSize(255);
p->SetUV(quadUV);
UnsafeUtility.MemCpyReplicate(p + 1, p, sizeof(Quad), span.Length - 1);
}
}
/// <summary>
/// /UseThisBefore WriteLinePositionOnly
/// </summary>
/// <param name="span"></param>
/// <param name="quadUV"></param>
public static unsafe void SetUpQuadUV(Span<Quad> span, Vector2 quadUV) {
fixed (Quad* p = span) {
*p = default;
p->SetSize(255);
p->SetUV(quadUV);
UnsafeUtility.MemCpyReplicate(p + 1, p, sizeof(Quad), span.Length - 1);
}
}
/// <summary>
/// /UseThisBefore WriteLinePositionOnly
/// </summary>
/// <param name="span"></param>
/// <param name="v"></param>
public static unsafe void SetUpForQuad(Span<Quad> span, Vector2 v) {
fixed (Quad* p = span) {
*p = default;
p->SetSize(255);
p->SetUV(v);
UnsafeUtility.MemCpyReplicate(p + 1, p, sizeof(Quad), span.Length - 1);
}
}
public static unsafe void SetUpUVForCircle(Span<Quad> span, Vector4 circleUV) {
fixed (Quad* p = span) {
*p = default;
p->V3.UV.x = p->V0.UV.x = circleUV.z;
p->V1.UV.y = p->V0.UV.y = circleUV.w + circleUV.y;
p->V2.UV.x = p->V1.UV.x = circleUV.x + circleUV.z;
p->V3.UV.y = p->V2.UV.y = circleUV.w;
UnsafeUtility.MemCpyReplicate(p + 1, p, sizeof(Quad), span.Length - 1);
}
}
public void SetColor(UiColor color) {
V0.Color = color;
V1.Color = color;
V2.Color = color;
V3.Color = color;
}
public void SetUV(Vector2 uv) {
V0.UV = uv;
V1.UV = uv;
V2.UV = uv;
V3.UV = uv;
}
public void SetSize(byte size) {
V3.Options.Size = V2.Options.Size = V1.Options.Size = V0.Options.Size = size;
}
public void SetColorAndSize(UiColor color, byte size) {
V3.Color = V2.Color = V1.Color = V0.Color = color;
V3.Options.Size = V2.Options.Size = V1.Options.Size = V0.Options.Size = size;
}
public void Rotate(float angle) {
Rotate(new Vector2(Mathf.Cos(angle), Mathf.Sin((angle))));
}
public void Rotate(Vector2 complex) {
var center = (V1.Position + V3.Position) / 2;
V0.Position = cross(complex, V0.Position - center) + center;
V1.Position = cross(complex, V1.Position - center) + center;
V2.Position = cross(complex, V2.Position - center) + center;
V3.Position = cross(complex, V3.Position - center) + center;
}
public void RotateFrom(Vector2 center, Vector2 complex) {
V0.Position = cross(complex, V0.Position - center) + center;
V1.Position = cross(complex, V1.Position - center) + center;
V2.Position = cross(complex, V2.Position - center) + center;
V3.Position = cross(complex, V3.Position - center) + center;
}
public void Scale(Vector2 scale) {
var center = (V1.Position + V3.Position) / 2;
V0.Position = scale * (V0.Position - center) + center;
V1.Position = scale * (V1.Position - center) + center;
V2.Position = scale * (V2.Position - center) + center;
V3.Position = scale * (V3.Position - center) + center;
}
public void ScaleFrom(Vector2 offset, Vector2 scale) {
V0.Position = scale * (V0.Position - offset);
V1.Position = scale * (V1.Position - offset);
V2.Position = scale * (V2.Position - offset);
V3.Position = scale * (V3.Position - offset);
}
public void Move(Vector2 delta) {
V0.Position += delta;
V1.Position += delta;
V2.Position += delta;
V3.Position += delta;
}
public void MoveX(float deltaX) {
V0.Position.x += deltaX;
V1.Position.x += deltaX;
V2.Position.x += deltaX;
V3.Position.x += deltaX;
}
public void MoveY(float deltaY) {
V0.Position.y += deltaY;
V1.Position.y += deltaY;
V2.Position.y += deltaY;
V3.Position.y += deltaY;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static Vector2 cross(Vector2 left, Vector2 right) {
return new Vector2(left.x * right.x - left.y * right.y, left.x * right.y + left.y * right.x);
}
}
} | Assets/ZimGui/Core/Quad.cs | Akeit0-ZimGui-Unity-cc82fb9 | [
{
"filename": "Assets/ZimGui/Core/UiMesh.cs",
"retrieved_chunk": " quad.V0.Position.y = center.y-height/Sqrt3;\n quad.V2.Position.x= quad.V0.Position.x = center.x-height/3;\n quad.V2.Position.y = center.y+height/Sqrt3;\n quad.V3.Position.x = center.x+height*2/3;\n quad.V3.Color = quad.V2.Color = quad.V0.Color = color;\n quad.V3.Options.Size = quad.V2.Options.Size = quad.V0.Options.Size = 255;\n quad.V3.UV = quad.V2.UV = quad.V0.UV = CircleCenter;\n quad.V1 = quad.V0;\n }\n public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, UiColor color) {",
"score": 0.8910007476806641
},
{
"filename": "Assets/ZimGui/Core/UiMesh.cs",
"retrieved_chunk": " quad.V2.Position.y= quad.V0.Position.y = center.y+height/3;\n quad.V2.Position.x = center.x+height/Sqrt3;\n quad.V3.Position.y = center.y-height*2/3;\n quad.V3.Color = quad.V2.Color = quad.V0.Color = color;\n quad.V3.Options.Size = quad.V2.Options.Size = quad.V0.Options.Size = 255;\n quad.V3.UV = quad.V2.UV = quad.V0.UV = CircleCenter;\n quad.V1 = quad.V0;\n } public void AddRightPointingTriangle(Vector2 center,float height, UiColor color) {\n ref var quad = ref Next();\n quad.V3.Position.y = center.y; ",
"score": 0.887980580329895
},
{
"filename": "Assets/ZimGui/Core/UiMesh.cs",
"retrieved_chunk": " quad.V1.Position.y = quad.V0.Position.y = rect.yMax;\n quad.V2.Position.x = quad.V1.Position.x = rect.xMax;\n quad.V3.Position.y = quad.V2.Position.y = rect.yMin;\n quad.V3.Color = quad.V2.Color = quad.V1.Color = quad.V0.Color = color;\n quad.V3.Options.Size = quad.V2.Options.Size = quad.V1.Options.Size = quad.V0.Options.Size = 255;\n quad.V3.UV = quad.V2.UV = quad.V1.UV = quad.V0.UV = CircleCenter;\n }\n public void AddRect(Rect rect, float width, UiColor backColor, UiColor frontColor) {\n var last = _quads.Length;\n if (_quads.Capacity <= last + 2) EnsureCapacity(last + 2);",
"score": 0.8786565065383911
},
{
"filename": "Assets/ZimGui/Core/UiMesh.cs",
"retrieved_chunk": " quad.V3.Color = quad.V2.Color = quad.V1.Color = quad.V0.Color = color;\n quad.V3.Options.Size = quad.V2.Options.Size = quad.V1.Options.Size = quad.V0.Options.Size = 255;\n quad.V3.UV = quad.V2.UV = quad.V1.UV = quad.V0.UV = CircleCenter;\n }\n public void InsertQuad(int index, Rect rect, UiColor color) {\n CheckAddLength(1);\n ;\n var scale = new Vector2(rect.width, -rect.height);\n var position = new Vector2(rect.xMin, rect.yMax);\n var uv = CircleCenter;",
"score": 0.8693286776542664
},
{
"filename": "Assets/ZimGui/Core/UiMesh.cs",
"retrieved_chunk": " quad2.V2.Position.x = quad2.V1.Position.x = center.x + frontRadius;\n quad2.V3.Position.y = quad2.V2.Position.y = center.y - frontRadius;\n quad2.V3.UV.x = quad2.V0.UV.x = quad1.V3.UV.x = quad1.V0.UV.x = CircleUV.z;\n quad2.V1.UV.y = quad2.V0.UV.y = quad1.V1.UV.y = quad1.V0.UV.y = CircleUV.w + CircleUV.y;\n quad2.V2.UV.x = quad2.V1.UV.x = quad1.V2.UV.x = quad1.V1.UV.x = CircleUV.x + CircleUV.z;\n quad2.V3.UV.y = quad2.V2.UV.y = quad1.V3.UV.y = quad1.V2.UV.y = CircleUV.w;\n }\n public void AddRadialFilledCircle(Vector2 center, float radius, UiColor color,float fillAmount) {\n AddRadialFilledUnScaledUV(CircleUV, center, radius*2, color, fillAmount);\n } ",
"score": 0.8682634830474854
}
] | csharp | UiColor rightColor, Vector2 uv) { |
using UnityEngine;
namespace ZimGui {
public enum FocusState {
NotFocus,
NewFocus,
Focus,
}
public static class IMInput {
public struct ModalWindowData {
public bool IsActive;
public bool Activated;
public Vector2 BasePoint;
public int BaseID;
}
public static ModalWindowData ModalWindow;
static | RayCaster _rayCaster = new RayCaster(16); |
public static void Add(int id, Rect rect) => _rayCaster.Add(id, rect);
public static void Add(Rect rect) => _rayCaster.Add(CurrentID, rect);
public static void Init() {
ModalWindow = default;
_rayCaster.Clear();
}
public static string InputString {
get {
if (_inputStringIsCalled) return _inputString;
_inputString = Input.inputString;
_inputStringIsCalled = false;
return _inputString;
}
}
static string _inputString;
static bool _inputStringIsCalled = false;
public static bool CanPush() => IsPointerDownActive | !IsPointerOn;
static bool _canPush;
public static void NewFrame(Vector2 pointerPos, bool pointerOn, bool pointerDown) {
CurrentID = 0;
FocusActivated = false;
_inputStringIsCalled = false;
IsPointerDownActive = IsPointerDown = pointerDown;
IsPointerActive = IsPointerOn = pointerOn;
_canPush = IsPointerDown | !IsPointerOn;
ModalWindow.Activated = false;
PointerPosition = pointerPos;
if (ModalWindow.IsActive) {
TargetID = -1;
}
else {
if (RetainFocus(pointerPos, pointerOn, pointerDown)) {
TargetID = FocusID;
}
else {
FocusID = -10;
TargetID = _rayCaster.Raycast(pointerPos);
}
_rayCaster.Clear();
}
}
public static void EndFrame() {
ModalWindow.IsActive &= ModalWindow.Activated;
if (0 <= FocusID && !FocusActivated) FocusID = -1;
}
static bool RetainFocus(Vector2 pointerPos, bool pointerOn, bool pointerDown) {
if (FocusID < -1) return false;
if (FocusNeedMouse) {
if (!pointerOn) {
FocusID = -10;
return false;
}
return true;
}
if (pointerDown && !FocusRect.Contains(pointerPos)) {
FocusID = -10;
return false;
}
return true;
}
public static FocusState GetModalWindowState(this Rect rect) {
if (ModalWindow.IsActive) {
if (ModalWindow.BaseID != CurrentID) return FocusState.NotFocus;
if (!rect.Contains(ModalWindow.BasePoint)) {
return FocusState.NotFocus;
}
ModalWindow.Activated = true;
return FocusState.Focus;
}
else {
if (!IsPointerDownActive || !ContainsActiveMouseDown(rect)) return FocusState.NotFocus;
IsPointerDownActive = false;
IsPointerActive = false;
ModalWindow.Activated = true;
ModalWindow.IsActive = true;
ModalWindow.BasePoint = rect.center;
ModalWindow.BaseID = CurrentID;
TargetID = -1;
return FocusState.NewFocus;
}
}
public static void CloseModalWindow() {
ModalWindow = default;
FocusID = -10;
}
public static bool IsFocusActive(this Rect rect, bool focusNeedMouse = true) {
if (TargetID != CurrentID || FocusActivated) return false;
if (focusNeedMouse && !(IsPointerDownActive || IsPointerActive)) return false;
if (FocusID == CurrentID) {
if (!rect.Contains(FocusPosition)) return false;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = rect.center;
if (!focusNeedMouse) FocusRect = rect;
FocusActivated = true;
return true;
}
if (-1 <= FocusID || !ContainsActiveMouseDown(rect)) return false;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = rect.center;
if (!focusNeedMouse) FocusRect = rect;
FocusNeedMouse = focusNeedMouse;
FocusActivated = true;
FocusID = CurrentID;
return true;
}
public static FocusState GetFocusState(this Rect rect, bool focusNeedMouse = true) {
if (TargetID != CurrentID || FocusActivated) return FocusState.NotFocus;
if (focusNeedMouse && !(IsPointerDownActive || IsPointerActive)) return FocusState.NotFocus;
if (FocusID == CurrentID) {
if (!rect.Contains(FocusPosition)) return FocusState.NotFocus;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = rect.center;
FocusRect = rect;
FocusActivated = true;
return FocusState.Focus;
}
if (-1 <= FocusID || !ContainsActiveMouseDown(rect)) return FocusState.NotFocus;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = rect.center;
FocusRect = rect;
FocusNeedMouse = focusNeedMouse;
FocusActivated = true;
FocusID = CurrentID;
IsPointerActive = false;
return FocusState.NewFocus;
}
public static void LoseFocus() {
FocusID = -10;
}
public static bool IsFocusActive(Vector2 center, float radius, bool focusNeedMouse = true) {
if (TargetID != CurrentID || FocusActivated) return false;
if (focusNeedMouse && !(IsPointerDownActive || IsPointerActive)) return false;
if (FocusID == CurrentID) {
if (radius * radius < (FocusPosition - center).sqrMagnitude) return false;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = center;
if (!focusNeedMouse) FocusRect = new Rect(center.x - radius, center.y - radius, 2 * radius, 2 * radius);
FocusActivated = true;
return true;
}
if (-1 <= FocusID || !CircleContainsActiveMouseDown(center, radius)) return false;
IsPointerDownActive = false;
IsPointerActive = false;
FocusPosition = center;
if (!focusNeedMouse) FocusRect = new Rect(center.x - radius, center.y - radius, 2 * radius, 2 * radius);
FocusNeedMouse = focusNeedMouse;
FocusActivated = true;
FocusID = CurrentID;
return true;
}
public static bool ContainsActiveMouse(this Rect rect) {
return TargetID == CurrentID && rect.Contains(PointerPosition);
}
public static bool CanPush(this Rect rect) {
return _canPush&& TargetID == CurrentID && rect.Contains(PointerPosition);
}
public static bool ContainsActiveMouseDown(this Rect rect) {
return IsPointerDownActive && TargetID == CurrentID && rect.Contains(PointerPosition);
}
public static bool ContainsMouse(this Rect rect) {
return rect.Contains(PointerPosition);
}
public static bool CircleContainsActiveMouse(Vector2 center, float radius) {
if (!IsPointerActive || TargetID != CurrentID) return false;
return ((PointerPosition - center).sqrMagnitude < radius * radius);
}
public static bool CircleContainsActiveMouseDown(Vector2 center, float radius) {
return IsPointerDownActive && TargetID == CurrentID &&
((PointerPosition - center).sqrMagnitude < radius * radius);
}
public static int TargetID;
public static int CurrentID;
public static Vector2 FocusPosition;
public static Rect FocusRect;
public static Vector2 PointerPosition;
public static bool FocusNeedMouse;
public static int FocusID;
public static bool FocusActivated;
public static bool IsPointerDown;
public static bool IsPointerOn;
public static bool IsPointerActive;
public static bool IsPointerDownActive;
}
} | Assets/ZimGui/IMInput.cs | Akeit0-ZimGui-Unity-cc82fb9 | [
{
"filename": "Assets/ZimGui/Window.cs",
"retrieved_chunk": "using System;\nusing UnityEngine;\nnamespace ZimGui {\n public class Window {\n public string Name;\n public readonly int WindowID;\n static int _lastWindowID;\n public Rect Rect;\n public Vector2 NextPosition;\n public bool Opened;",
"score": 0.9048842787742615
},
{
"filename": "Assets/ZimGui/InputFieldData.cs",
"retrieved_chunk": "using System;\nusing System.Collections.Generic;\nusing UnityEngine;\nnamespace ZimGui {\n public struct InputFieldData {\n public int Length;\n public int CaretPosition;\n public float FocusTime;\n //public bool IsDelayed;\n // public InputFieldData(int length,bool isDelayed) {",
"score": 0.8872402310371399
},
{
"filename": "Assets/ZimGui/IM.cs",
"retrieved_chunk": " public static bool GetRightArrowKey => Input.GetKey(KeyCode.RightArrow);\n public static bool GetRightArrowKeyDown => Input.GetKeyDown(KeyCode.RightArrow);\n public static UiMesh Mesh;\n public static Camera Camera;\n static Range _popUpRange;\n public static bool IsInModalWindow;\n public readonly struct ModalWindowArea : IDisposable {\n public readonly int StartIndex;\n public readonly int WindowID;\n ModalWindowArea(int startIndex) {",
"score": 0.8794108629226685
},
{
"filename": "Assets/ZimGui/RayCaster.cs",
"retrieved_chunk": "using System;\nusing UnityEngine;\nnamespace ZimGui {\n public struct RayCaster {\n public Rect[] Rects;\n public int[] TargetID;\n public int Count;\n public RayCaster(int capacity) {\n Rects = new Rect[capacity];\n TargetID = new int[capacity];",
"score": 0.878692626953125
},
{
"filename": "Assets/ZimGui/Core/Quad.cs",
"retrieved_chunk": " public byte Padding1;\n public byte Padding2;\n }\n [StructLayout(LayoutKind.Sequential)]\n public struct VertexData {\n /// <summary>\n /// Screen Position\n /// </summary>\n public Vector2 Position;\n public UiColor Color;",
"score": 0.8678865432739258
}
] | csharp | RayCaster _rayCaster = new RayCaster(16); |
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Sandland.SceneTool.Editor.Common.Data;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UIElements;
using Object = UnityEngine.Object;
namespace Sandland.SceneTool.Editor.Common.Utils
{
internal static class AssetDatabaseUtils
{
public static VisualTreeAsset FindAndLoadVisualTreeAsset(string name = null) =>
FindAndLoadAsset<VisualTreeAsset>(name);
public static StyleSheet FindAndLoadStyleSheet(string name = null) => FindAndLoadAsset<StyleSheet>(name);
public static bool TryFindAndLoadAsset<T>(out T result, string name = null) where T : Object
{
try
{
result = FindAndLoadAsset<T>(name);
return true;
}
catch
{
result = null;
return false;
}
}
public static T FindAndLoadAsset<T>(string name = null) where T : Object
{
// TODO: Reuse code from FindAssets
var typeName = typeof(T).Name;
var query = string.IsNullOrEmpty(name) ? $"t:{typeName}" : $"{name} t:{typeName}";
var guids = AssetDatabase.FindAssets(query);
switch (guids.Length)
{
case 0:
throw new FileNotFoundException($"Cant locate {typeName} file with the name: {name}");
case > 1:
Debug.LogWarning(
$"Found more than one {typeName} file with the name: {name}; Loading only the first");
break;
}
var path = AssetDatabase.GUIDToAssetPath(guids.First());
var asset = AssetDatabase.LoadAssetAtPath<T>(path);
if (asset == null)
{
throw new FileNotFoundException($"Unable to load the {typeName} with the name {name}");
}
return asset;
}
public static bool TryFindAssets<T>(out AssetFileInfo[] result, string name = null)
{
try
{
result = FindAssets<T>(name);
return result.Length > 0;
}
catch
{
result = null;
return false;
}
}
public static SceneInfo[] FindScenes(string name = null)
{
var assets = FindAssets<Scene>(name);
var result = new List<SceneInfo>(assets.Length);
var sceneBuildIndexes = Utils.GetSceneBuildIndexes();
var assetsInBundles = Utils.GetAssetsInBundles();
const string packagesPrefix = "Packages/";
foreach (var asset in assets)
{
if (asset.Path.StartsWith(packagesPrefix))
{
continue;
}
SceneInfo info;
if (Utils.IsAssetAddressable(asset.Guid, out var address))
{
info = SceneInfo.Create.Addressable(address, asset.Name, asset.Path, asset.Guid, asset.Labels);
}
else if (Utils.IsAssetInBundle(assetsInBundles, asset.Path, out var bundleName))
{
info = SceneInfo.Create.AssetBundle(asset.Name, asset.Path, asset.Guid, bundleName, asset.Labels);
}
else if (sceneBuildIndexes.ContainsSceneGuid(asset.Guid, out var buildIndex))
{
info = SceneInfo.Create.BuiltIn(asset.Name, buildIndex, asset.Path, asset.Guid, asset.Labels);
}
else
{
info = SceneInfo.Create.Default(asset.Name, asset.Path, asset.Guid, asset.Labels);
}
result.Add(info);
}
return result.ToArray();
}
public static | AssetFileInfo[] FindAssets<T>(string name = null)
{ |
var typeName = typeof(T).Name;
var query = string.IsNullOrEmpty(name) ? $"t:{typeName}" : $"{name} t:{typeName}";
var guids = AssetDatabase.FindAssets(query);
if (guids.Length == 0)
{
return Array.Empty<AssetFileInfo>();
}
var result = new AssetFileInfo[guids.Length];
for (var i = 0; i < guids.Length; i++)
{
var guid = guids[i];
var path = AssetDatabase.GUIDToAssetPath(guid);
var assetName = Path.GetFileNameWithoutExtension(path);
var labels = AssetDatabase.GetLabels(new GUID(guid)).ToList();
result[i] = new AssetFileInfo(assetName, path, guid, string.Empty, labels);
}
return result;
}
public static void SetLabels<T>(this AssetFileInfo info) where T : Object
{
var asset = AssetDatabase.LoadAssetAtPath<T>(info.Path);
AssetDatabase.SetLabels(asset, info.Labels.ToArray());
}
public static void SetLabel<T>(string path, string label) where T : Object
{
var asset = AssetDatabase.LoadAssetAtPath<T>(path);
var labels = AssetDatabase.GetLabels(asset).ToList();
if (labels.Contains(label))
{
return;
}
labels.Add(label);
AssetDatabase.SetLabels(asset, labels.ToArray());
}
}
} | Assets/SceneTools/Editor/Common/Utils/AssetDatabaseUtils.cs | migus88-Sandland.SceneTools-64e9f8c | [
{
"filename": "Assets/SceneTools/Editor/Common/Data/SceneInfo.cs",
"retrieved_chunk": " }\n public static SceneInfo AssetBundle(string name, string path, string guid, string bundleName, List<string> labels = null)\n {\n return new SceneInfo(name, path, guid, bundleName, labels)\n {\n ImportType = SceneImportType.AssetBundle\n };\n }\n public static SceneInfo Default(string name, string path, string guid, List<string> labels = null)\n {",
"score": 0.851482629776001
},
{
"filename": "Assets/SceneTools/Editor/Common/Data/SceneInfo.cs",
"retrieved_chunk": " return new SceneInfo(name, path, guid, string.Empty, labels)\n {\n ImportType = SceneImportType.None\n };\n }\n public static SceneInfo BuiltIn(string name, int buildIndex, string path, string guid, List<string> labels = null)\n {\n return new SceneInfo(name, path, guid, string.Empty, labels)\n {\n ImportType = SceneImportType.BuildSettings,",
"score": 0.8379383087158203
},
{
"filename": "Assets/SceneTools/Editor/Services/FavoritesService.cs",
"retrieved_chunk": " info.Labels.Add(FavoriteSceneLabel);\n info.SetLabels<SceneAsset>();\n FavoritesChanged?.Invoke();\n }\n public static void RemoveFromFavorites(this AssetFileInfo info)\n {\n if (!info.IsFavorite())\n {\n return;\n }",
"score": 0.8337522149085999
},
{
"filename": "Assets/SceneTools/Editor/Common/Utils/Utils.cs",
"retrieved_chunk": " {\n var scene = EditorBuildSettings.scenes[i];\n collection.Add(scene.guid, i);\n }\n return collection;\n }\n public static bool ContainsSceneGuid(this Dictionary<GUID, int> sceneBuildIndexes, string sceneGuid,\n out int buildIndex)\n {\n buildIndex = -1;",
"score": 0.8171576261520386
},
{
"filename": "Assets/SceneTools/Editor/Common/Data/SceneInfo.cs",
"retrieved_chunk": " }\n public static class Create\n {\n public static SceneInfo Addressable(string address, string name = null, string path = null, string guid = null, List<string> labels = null)\n {\n return new SceneInfo(name, path, guid, string.Empty, labels)\n {\n ImportType = SceneImportType.Addressables,\n Address = address\n };",
"score": 0.8171083927154541
}
] | csharp | AssetFileInfo[] FindAssets<T>(string name = null)
{ |
using NowPlaying.Utils;
using NowPlaying.Models;
using Playnite.SDK.Data;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows.Threading;
using static NowPlaying.Models.GameCacheManager;
using Playnite.SDK;
namespace NowPlaying.ViewModels
{
public class GameCacheManagerViewModel : ViewModelBase
{
public readonly NowPlaying plugin;
public readonly ILogger logger;
private readonly string pluginUserDataPath;
private readonly string cacheRootsJsonPath;
private readonly string gameCacheEntriesJsonPath;
private readonly string installAverageBpsJsonPath;
public readonly GameCacheManager gameCacheManager;
public ObservableCollection<CacheRootViewModel> CacheRoots { get; private set; }
public ObservableCollection<GameCacheViewModel> GameCaches { get; private set; }
public SortedDictionary<string, long> InstallAverageBps { get; private set; }
public GameCacheManagerViewModel(NowPlaying plugin, ILogger logger)
{
this.plugin = plugin;
this.logger = logger;
this.pluginUserDataPath = plugin.GetPluginUserDataPath();
cacheRootsJsonPath = Path.Combine(pluginUserDataPath, "CacheRoots.json");
gameCacheEntriesJsonPath = Path.Combine(pluginUserDataPath, "gameCacheEntries.json");
installAverageBpsJsonPath = Path.Combine(pluginUserDataPath, "InstallAverageBps.json");
gameCacheManager = new GameCacheManager(logger);
CacheRoots = new ObservableCollection<CacheRootViewModel>();
GameCaches = new ObservableCollection<GameCacheViewModel>();
InstallAverageBps = new SortedDictionary<string, long>();
}
public void UpdateGameCaches()
{
// . absorb possible collection-modified exception when adding new game caches
try
{
foreach (var gameCache in GameCaches)
{
gameCache.UpdateCacheRoot();
}
}
catch { }
OnPropertyChanged(nameof(GameCaches));
}
public void AddCacheRoot(string rootDirectory, double maximumFillLevel)
{
if (!CacheRootExists(rootDirectory))
{
// . add cache root
var root = new CacheRoot(rootDirectory, maximumFillLevel);
gameCacheManager.AddCacheRoot(root);
// . add cache root view model
CacheRoots.Add(new CacheRootViewModel(this, root));
SaveCacheRootsToJson();
logger.Info($"Added cache root '{rootDirectory}' with {maximumFillLevel}% max fill.");
}
}
public void RemoveCacheRoot(string rootDirectory)
{
if (FindCacheRoot(rootDirectory)?.GameCaches.Count() == 0)
{
// . remove cache root
gameCacheManager.RemoveCacheRoot(rootDirectory);
// . remove cache root view model
CacheRoots.Remove(FindCacheRoot(rootDirectory));
SaveCacheRootsToJson();
logger.Info($"Removed cache root '{rootDirectory}'.");
}
}
public bool CacheRootExists(string rootDirectory)
{
return CacheRoots.Where(r => r.Directory == rootDirectory).Count() > 0;
}
public CacheRootViewModel FindCacheRoot(string rootDirectory)
{
var roots = CacheRoots.Where(r => r.Directory == rootDirectory);
return rootDirectory != null && roots.Count() == 1 ? roots.First() : null;
}
public string AddGameCache
(
string cacheId,
string title,
string installDir,
string exePath,
string xtraArgs,
string cacheRootDir,
string cacheSubDir = null,
GameCachePlatform platform = GameCachePlatform.WinPC)
{
if (!GameCacheExists(cacheId) && CacheRootExists(cacheRootDir))
{
// . re-encode cacheSubDir as 'null' if it represents the file-safe game title.
if (cacheSubDir?.Equals(DirectoryUtils.ToSafeFileName(title)) == true)
{
cacheSubDir = null;
}
// . create new game cache entry
gameCacheManager.AddGameCacheEntry(cacheId, title, installDir, exePath, xtraArgs, cacheRootDir, cacheSubDir, platform: platform);
// . update install/cache dir stats/sizes
var entry = gameCacheManager.GetGameCacheEntry(cacheId);
try
{
entry.UpdateInstallDirStats();
entry.UpdateCacheDirStats();
}
catch (Exception ex)
{
logger.Error($"Error updating install/cache dir stats for '{title}': {ex.Message}");
}
// . add new game cache view model
var cacheRoot = FindCacheRoot(cacheRootDir);
var gameCache = new GameCacheViewModel(this, entry, cacheRoot);
// . use UI dispatcher if necessary (i.e. if this is called from a Game Enabler / background task)
if (plugin.panelView.Dispatcher.CheckAccess())
{
GameCaches.Add(gameCache);
}
else
{
plugin.panelView.Dispatcher.Invoke(DispatcherPriority.Normal, new ThreadStart(() => GameCaches.Add(gameCache)));
}
// . update respective cache root view model of added game cache
cacheRoot.UpdateGameCaches();
SaveGameCacheEntriesToJson();
logger.Info($"Added game cache: '{entry}'");
// . return the games cache directory (or null)
return entry.CacheDir;
}
else
{
// . couldn't create, null cache directory
return null;
}
}
public void RemoveGameCache(string cacheId)
{
var gameCache = FindGameCache(cacheId);
if (gameCache != null)
{
// . remove game cache entry
gameCacheManager.RemoveGameCacheEntry(cacheId);
// . remove game cache view model
GameCaches.Remove(gameCache);
// . notify cache root view model of the change
gameCache.cacheRoot.UpdateGameCaches();
SaveGameCacheEntriesToJson();
logger.Info($"Removed game cache: '{gameCache.entry}'");
}
}
public bool GameCacheExists(string cacheId)
{
return GameCaches.Where(gc => gc.Id == cacheId).Count() > 0;
}
public GameCacheViewModel FindGameCache(string cacheId)
{
var caches = GameCaches.Where(gc => gc.Id == cacheId);
return caches.Count() == 1 ? caches.First() : null;
}
public bool IsPopulateInProgess(string cacheId)
{
return gameCacheManager.IsPopulateInProgess(cacheId);
}
public void SetGameCacheAndDirStateAsPlayed(string cacheId)
{
if (GameCacheExists(cacheId))
{
gameCacheManager.SetGameCacheAndDirStateAsPlayed(cacheId);
}
}
public long GetInstallAverageBps(string installDir, long avgBytesPerFile, int speedLimitIpg=0)
{
string installDevice = Directory.GetDirectoryRoot(installDir);
string key;
// . assign to a "file density" bin [0..7], spaced as powers of 2 of 16KB/file
var fileDensityBin = MathUtils.Clamp((int)MathUtils.Log2(1 + avgBytesPerFile / 131072) - 1, 0, 7);
string densityBin = $"[{fileDensityBin}]";
if (speedLimitIpg > 0)
{
int roundedUpToNearestFiveIpg = ((speedLimitIpg + 4) / 5) * 5;
string ipgTag = $"(IPG={roundedUpToNearestFiveIpg})";
// . return the binned AvgBps, if exists
if (InstallAverageBps.ContainsKey(key = installDevice + densityBin + ipgTag))
{
return InstallAverageBps[key];
}
// . otherwise, return baseline AvgBps, if exists
else if (InstallAverageBps.ContainsKey(key = installDevice + ipgTag))
{
return InstallAverageBps[key];
}
// . otherwise, return default value
else
{
return (long)(plugin.Settings.DefaultAvgMegaBpsSpeedLimited * 1048576.0);
}
}
else
{
// . return the binned AvgBps, if exists
if (InstallAverageBps.ContainsKey(key = installDevice + densityBin))
{
return InstallAverageBps[key];
}
// . otherwise, return baseline AvgBps, if exists
else if (InstallAverageBps.ContainsKey(key = installDevice))
{
return InstallAverageBps[key];
}
// . otherwise, return default value
else
{
return (long)(plugin.Settings.DefaultAvgMegaBpsNormal * 1048576.0);
}
}
}
public void UpdateInstallAverageBps
(
string installDir,
long avgBytesPerFile,
long averageBps,
int speedLimitIpg = 0)
{
string installDevice = Directory.GetDirectoryRoot(installDir);
string ipgTag = string.Empty;
string key;
// . assign to a "file density" bin [0..7], spaced as powers of 2 of 16KB/file
var fileDensityBin = MathUtils.Clamp((int)MathUtils.Log2(1 + avgBytesPerFile / 131072) - 1, 0, 7);
string densityBin = $"[{fileDensityBin}]";
if (speedLimitIpg > 0)
{
int roundedUpToNearestFiveIpg = ((speedLimitIpg + 4) / 5) * 5;
ipgTag = $"(IPG={roundedUpToNearestFiveIpg})";
}
// . update or add new binned AvgBps entry
if (InstallAverageBps.ContainsKey(key = installDevice + densityBin + ipgTag))
{
// take 90/10 average of saved Bps and current value, respectively
InstallAverageBps[key] = (9 * InstallAverageBps[key] + averageBps) / 10;
}
else
{
InstallAverageBps.Add(key, averageBps);
}
// . update or add new baseline AvgBps entry
if (InstallAverageBps.ContainsKey(key = installDevice + ipgTag))
{
// take 90/10 average of saved Bps and current value, respectively
InstallAverageBps[key] = (9 * InstallAverageBps[key] + averageBps) / 10;
}
else
{
InstallAverageBps.Add(key, averageBps);
}
SaveInstallAverageBpsToJson();
}
public void SaveInstallAverageBpsToJson()
{
try
{
File.WriteAllText(installAverageBpsJsonPath, Serialization.ToJson(InstallAverageBps));
}
catch (Exception ex)
{
logger.Error($"SaveInstallAverageBpsToJson to '{installAverageBpsJsonPath}' failed: {ex.Message}");
}
}
public void LoadInstallAverageBpsFromJson()
{
if (File.Exists(installAverageBpsJsonPath))
{
try
{
InstallAverageBps = Serialization.FromJsonFile<SortedDictionary<string, long>>(installAverageBpsJsonPath);
}
catch (Exception ex)
{
logger.Error($"LoadInstallAverageBpsFromJson from '{installAverageBpsJsonPath}' failed: {ex.Message}");
SaveInstallAverageBpsToJson();
}
}
else
{
SaveInstallAverageBpsToJson();
}
}
public void SaveCacheRootsToJson()
{
try
{
File.WriteAllText(cacheRootsJsonPath, Serialization.ToJson(gameCacheManager.GetCacheRoots()));
}
catch (Exception ex)
{
logger.Error($"SaveCacheRootsToJson to '{cacheRootsJsonPath}' failed: {ex.Message}");
}
}
public void LoadCacheRootsFromJson()
{
if (File.Exists(cacheRootsJsonPath))
{
var roots = new List<CacheRoot>();
try
{
roots = Serialization.FromJsonFile<List<CacheRoot>>(cacheRootsJsonPath);
}
catch (Exception ex)
{
logger.Error($"LoadCacheRootsFromJson from '{cacheRootsJsonPath}' failed: {ex.Message}");
}
foreach (var root in roots)
{
if (DirectoryUtils.ExistsAndIsWritable(root.Directory) || DirectoryUtils.MakeDir(root.Directory))
{
gameCacheManager.AddCacheRoot(root);
CacheRoots.Add(new CacheRootViewModel(this, root));
}
else
{
plugin.NotifyError(plugin.FormatResourceString("LOCNowPlayingRemovingCacheRootNotFoundWritableFmt", root.Directory));
}
}
}
SaveCacheRootsToJson();
}
public void SaveGameCacheEntriesToJson()
{
try
{
File.WriteAllText(gameCacheEntriesJsonPath, Serialization.ToJson(gameCacheManager.GetGameCacheEntries()));
}
catch (Exception ex)
{
logger.Error($"SaveGameCacheEntriesToJson to '{gameCacheEntriesJsonPath}' failed: {ex.Message}");
}
}
public void LoadGameCacheEntriesFromJson()
{
List<string> needToUpdateCacheStats = new List<string>();
if (File.Exists(gameCacheEntriesJsonPath))
{
var entries = new List<GameCacheEntry>();
try
{
entries = Serialization.FromJsonFile<List<GameCacheEntry>>(gameCacheEntriesJsonPath);
}
catch (Exception ex)
{
logger.Error($"LoadGameCacheEntriesFromJson from '{gameCacheEntriesJsonPath}' failed: {ex.Message}");
}
foreach (var entry in entries)
{
if (plugin.FindNowPlayingGame(entry.Id) != null)
{
var cacheRoot = FindCacheRoot(entry.CacheRoot);
if (cacheRoot != null)
{
if (entry.CacheSizeOnDisk < entry.CacheSize)
{
needToUpdateCacheStats.Add(entry.Id);
}
gameCacheManager.AddGameCacheEntry(entry);
GameCaches.Add(new GameCacheViewModel(this, entry, cacheRoot));
}
else
{
plugin.NotifyWarning(plugin.FormatResourceString("LOCNowPlayingDisableGameCacheRootNotFoundFmt2", entry.CacheRoot, entry.Title));
plugin.DisableNowPlayingGameCaching(plugin.FindNowPlayingGame(entry.Id), entry.InstallDir, entry.ExePath, entry.XtraArgs);
}
}
else
{
plugin.NotifyWarning($"NowPlaying enabled game not found; disabling game caching for '{entry.Title}'.");
}
}
plugin.panelViewModel.RefreshGameCaches();
}
if (needToUpdateCacheStats.Count > 0)
{
plugin.topPanelViewModel.NowProcessing(true, "Updating cache sizes...");
foreach (var id in needToUpdateCacheStats)
{
var gameCache = FindGameCache(id);
gameCache?.entry.UpdateCacheDirStats();
gameCache?.UpdateCacheSpaceWillFit();
}
plugin.topPanelViewModel.NowProcessing(false, "Updating cache sizes...");
}
SaveGameCacheEntriesToJson();
// . notify cache roots of updates to their resective game caches
foreach (var cacheRoot in CacheRoots)
{
cacheRoot.UpdateGameCaches();
}
}
public (string cacheRootDir, string cacheSubDir) FindCacheRootAndSubDir(string installDirectory)
{
return gameCacheManager.FindCacheRootAndSubDir(installDirectory);
}
public bool GameCacheIsUninstalled(string cacheId)
{
return gameCacheManager.GameCacheExistsAndEmpty(cacheId);
}
public string ChangeGameCacheRoot(GameCacheViewModel gameCache, CacheRootViewModel newCacheRoot)
{
if (gameCache.IsUninstalled() && gameCache.cacheRoot != newCacheRoot)
{
var oldCacheRoot = gameCache.cacheRoot;
gameCacheManager.ChangeGameCacheRoot(gameCache.Id, newCacheRoot.Directory);
gameCache.cacheRoot = newCacheRoot;
gameCache.UpdateCacheRoot();
// . reflect removal of game from previous cache root
oldCacheRoot.UpdateGameCaches();
}
return gameCache.CacheDir;
}
public bool IsGameCacheDirectory(string possibleCacheDir)
{
return gameCacheManager.IsGameCacheDirectory(possibleCacheDir);
}
public void Shutdown()
{
gameCacheManager.Shutdown();
}
public bool IsGameCacheInstalled(string cacheId)
{
return gameCacheManager.GameCacheExistsAndPopulated(cacheId);
}
private class InstallCallbacks
{
private readonly GameCacheManager manager;
private readonly GameCacheViewModel gameCache;
private readonly Action< | GameCacheJob> InstallDone; |
private readonly Action<GameCacheJob> InstallCancelled;
private bool cancelOnMaxFill;
public InstallCallbacks
(
GameCacheManager manager,
GameCacheViewModel gameCache,
Action<GameCacheJob> installDone,
Action<GameCacheJob> installCancelled
)
{
this.manager = manager;
this.gameCache = gameCache;
this.InstallDone = installDone;
this.InstallCancelled = installCancelled;
this.cancelOnMaxFill = false;
}
public void Done(object sender, GameCacheJob job)
{
if (job.entry.Id == gameCache.Id)
{
manager.eJobDone -= this.Done;
manager.eJobCancelled -= this.Cancelled;
manager.eJobStatsUpdated -= this.MaxFillLevelCanceller;
InstallDone(job);
}
}
public void Cancelled(object sender, GameCacheJob job)
{
if (job.entry.Id == gameCache.Id)
{
manager.eJobDone -= this.Done;
manager.eJobCancelled -= this.Cancelled;
manager.eJobStatsUpdated -= this.MaxFillLevelCanceller;
if (cancelOnMaxFill)
{
job.cancelledOnMaxFill = true;
}
InstallCancelled(job);
}
}
public void MaxFillLevelCanceller(object sender, string cacheId)
{
if (cacheId == gameCache.Id)
{
// . automatically pause cache installation if max fill level exceeded
if (gameCache.cacheRoot.BytesAvailableForCaches <= 0)
{
cancelOnMaxFill = true;
manager.CancelPopulateOrResume(cacheId);
}
}
}
}
public void InstallGameCache
(
GameCacheViewModel gameCache,
RoboStats jobStats,
Action<GameCacheJob> installDone,
Action<GameCacheJob> installCancelled,
int interPacketGap = 0,
PartialFileResumeOpts pfrOpts = null)
{
var callbacks = new InstallCallbacks(gameCacheManager, gameCache, installDone, installCancelled);
gameCacheManager.eJobDone += callbacks.Done;
gameCacheManager.eJobCancelled += callbacks.Cancelled;
gameCacheManager.eJobStatsUpdated += callbacks.MaxFillLevelCanceller;
gameCacheManager.StartPopulateGameCacheJob(gameCache.Id, jobStats, interPacketGap, pfrOpts);
}
public void CancelInstall(string cacheId)
{
gameCacheManager.CancelPopulateOrResume(cacheId);
}
private class UninstallCallbacks
{
private readonly GameCacheManager manager;
private readonly GameCacheViewModel gameCache;
private readonly Action<GameCacheJob> UninstallDone;
private readonly Action<GameCacheJob> UninstallCancelled;
public UninstallCallbacks
(
GameCacheManager manager,
GameCacheViewModel gameCache,
Action<GameCacheJob> uninstallDone,
Action<GameCacheJob> uninstallCancelled)
{
this.manager = manager;
this.gameCache = gameCache;
this.UninstallDone = uninstallDone;
this.UninstallCancelled = uninstallCancelled;
}
public void Done(object sender, GameCacheJob job)
{
if (job.entry.Id == gameCache.Id)
{
manager.eJobDone -= this.Done;
manager.eJobCancelled -= this.Cancelled;
UninstallDone(job);
}
}
public void Cancelled(object sender, GameCacheJob job)
{
if (job.entry.Id == gameCache.Id)
{
manager.eJobDone -= this.Done;
manager.eJobCancelled -= this.Cancelled;
UninstallCancelled(job);
}
}
}
public void UninstallGameCache
(
GameCacheViewModel gameCache,
bool cacheWriteBackOption,
Action<GameCacheJob> uninstallDone,
Action<GameCacheJob> uninstallCancelled)
{
var callbacks = new UninstallCallbacks(gameCacheManager, gameCache, uninstallDone, uninstallCancelled);
gameCacheManager.eJobDone += callbacks.Done;
gameCacheManager.eJobCancelled += callbacks.Cancelled;
gameCacheManager.StartEvictGameCacheJob(gameCache.Id, cacheWriteBackOption);
}
public DirtyCheckResult CheckCacheDirty(string cacheId)
{
DirtyCheckResult result = new DirtyCheckResult();
var diff = gameCacheManager.CheckCacheDirty(cacheId);
// . focus is on New/Newer files in the cache vs install directory only
// -> Old/missing files will be ignored
//
result.isDirty = diff != null && (diff.NewerFiles.Count > 0 || diff.NewFiles.Count > 0);
if (result.isDirty)
{
string nl = Environment.NewLine;
if (diff.NewerFiles.Count > 0)
{
result.summary += plugin.FormatResourceString("LOCNowPlayingDirtyCacheModifiedFilesFmt", diff.NewerFiles.Count) + nl;
foreach (var file in diff.NewerFiles) result.summary += "• " + file + nl;
result.summary += nl;
}
if (diff.NewFiles.Count > 0)
{
result.summary += plugin.FormatResourceString("LOCNowPlayingDirtyCacheNewFilesFmt", diff.NewFiles.Count) + nl;
foreach (var file in diff.NewFiles) result.summary += "• " + file + nl;
result.summary += nl;
}
if (diff.ExtraFiles.Count > 0)
{
result.summary += plugin.FormatResourceString("LOCNowPlayingDirtyCacheMissingFilesFmt", diff.ExtraFiles.Count) + nl;
foreach (var file in diff.ExtraFiles) result.summary += "• " + file + nl;
result.summary += nl;
}
if (diff.OlderFiles.Count > 0)
{
result.summary += plugin.FormatResourceString("LOCNowPlayingDirtyCacheOutOfDateFilesFmt", diff.OlderFiles.Count) + nl;
foreach (var file in diff.OlderFiles) result.summary += "• " + file + nl;
result.summary += nl;
}
}
return result;
}
}
}
| source/ViewModels/GameCacheManagerViewModel.cs | gittromney-Playnite-NowPlaying-23eec41 | [
{
"filename": "source/NowPlayingGameEnabler.cs",
"retrieved_chunk": "{\n public class NowPlayingGameEnabler\n {\n private readonly ILogger logger = NowPlaying.logger;\n private readonly NowPlaying plugin;\n private readonly IPlayniteAPI PlayniteApi;\n private readonly GameCacheManagerViewModel cacheManager;\n private readonly Game game;\n private readonly string cacheRootDir;\n public string Id => game.Id.ToString();",
"score": 0.8639010787010193
},
{
"filename": "source/ViewModels/GameCacheViewModel.cs",
"retrieved_chunk": " public TimeSpan InstallEtaTimeSpan { get; private set; }\n public string InstallEta { get; private set; }\n public string CacheRootSpaceAvailable { get; private set; }\n public string CacheRootSpaceAvailableColor => cacheRoot.BytesAvailableForCaches > 0 ? \"TextBrush\" : \"WarningBrush\";\n public bool PartialFileResume { get; set; }\n public GameCacheViewModel(GameCacheManagerViewModel manager, GameCacheEntry entry, CacheRootViewModel cacheRoot)\n {\n this.manager = manager;\n this.plugin = manager.plugin;\n this.entry = entry;",
"score": 0.8623655438423157
},
{
"filename": "source/ViewModels/AddGameCachesViewModel.cs",
"retrieved_chunk": "using System.Windows.Threading;\nnamespace NowPlaying.ViewModels\n{\n public class AddGameCachesViewModel : ViewModelBase\n {\n private readonly NowPlaying plugin;\n private readonly Window popup;\n private readonly List<CacheRootViewModel> cacheRoots;\n private readonly List<GameViewModel> allEligibleGames;\n private string searchText;",
"score": 0.8608590960502625
},
{
"filename": "source/ViewModels/CacheRootViewModel.cs",
"retrieved_chunk": " public long BytesAvailableForCaches { get; private set; }\n public string SpaceAvailableForCaches { get; private set; }\n public string SpaceAvailableForCachesColor => BytesAvailableForCaches > 0 ? \"TextBrush\" : \"WarningBrush\";\n public long bytesReservedOnDevice;\n public string ReservedSpaceOnDevice { get; private set; }\n public CacheRootViewModel(GameCacheManagerViewModel manager, CacheRoot root)\n {\n this.manager = manager;\n this.plugin = manager.plugin;\n this.root = root;",
"score": 0.8605530261993408
},
{
"filename": "source/NowPlayingInstallController.cs",
"retrieved_chunk": " public readonly RoboStats jobStats;\n public readonly GameCacheViewModel gameCache;\n public readonly GameCacheManagerViewModel cacheManager;\n public readonly InstallProgressViewModel progressViewModel;\n public readonly InstallProgressView progressView;\n private Action onPausedAction;\n public int speedLimitIpg;\n private bool deleteCacheOnJobCancelled { get; set; } = false;\n private bool pauseOnPlayniteExit { get; set; } = false;\n public NowPlayingInstallController(NowPlaying plugin, Game nowPlayingGame, GameCacheViewModel gameCache, int speedLimitIpg = 0) ",
"score": 0.8557143807411194
}
] | csharp | GameCacheJob> InstallDone; |
// Licensed under the MIT License. See LICENSE in the project root for license information.
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Scripting;
using Utilities.WebRequestRest;
namespace BlockadeLabs.Skyboxes
{
public sealed class SkyboxEndpoint : BlockadeLabsBaseEndpoint
{
[Preserve]
private class SkyboxInfoRequest
{
[Preserve]
[JsonConstructor]
public SkyboxInfoRequest([JsonProperty("request")] SkyboxInfo skyboxInfo)
{
SkyboxInfo = skyboxInfo;
}
[Preserve]
[JsonProperty("request")]
public SkyboxInfo SkyboxInfo { get; }
}
[Preserve]
private class SkyboxOperation
{
[Preserve]
[JsonConstructor]
public SkyboxOperation(
[JsonProperty("success")] string success,
[JsonProperty("error")] string error)
{
Success = success;
Error = error;
}
[Preserve]
[JsonProperty("success")]
public string Success { get; }
[Preserve]
[JsonProperty("Error")]
public string Error { get; }
}
public SkyboxEndpoint(BlockadeLabsClient client) : base(client) { }
protected override string Root => string.Empty;
/// <summary>
/// Returns the list of predefined styles that can influence the overall aesthetic of your skybox generation.
/// </summary>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns>A list of <see cref="SkyboxStyle"/>s.</returns>
public async Task<IReadOnlyList<SkyboxStyle>> GetSkyboxStylesAsync(CancellationToken cancellationToken = default)
{
var response = await Rest.GetAsync(GetUrl("skybox/styles"), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
return JsonConvert.DeserializeObject<IReadOnlyList<SkyboxStyle>>(response.Body, client.JsonSerializationOptions);
}
/// <summary>
/// Generate a skybox image.
/// </summary>
/// <param name="skyboxRequest"><see cref="SkyboxRequest"/>.</param>
/// <param name="pollingInterval">Optional, polling interval in seconds.</param>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns><see cref="SkyboxInfo"/>.</returns>
public async Task<SkyboxInfo> GenerateSkyboxAsync(SkyboxRequest skyboxRequest, int? pollingInterval = null, CancellationToken cancellationToken = default)
{
var formData = new WWWForm();
formData.AddField("prompt", skyboxRequest.Prompt);
if (!string.IsNullOrWhiteSpace(skyboxRequest.NegativeText))
{
formData.AddField("negative_text", skyboxRequest.NegativeText);
}
if (skyboxRequest.Seed.HasValue)
{
formData.AddField("seed", skyboxRequest.Seed.Value);
}
if (skyboxRequest.SkyboxStyleId.HasValue)
{
formData.AddField("skybox_style_id", skyboxRequest.SkyboxStyleId.Value);
}
if (skyboxRequest.RemixImagineId.HasValue)
{
formData.AddField("remix_imagine_id", skyboxRequest.RemixImagineId.Value);
}
if (skyboxRequest.Depth)
{
formData.AddField("return_depth", skyboxRequest.Depth.ToString());
}
if (skyboxRequest.ControlImage != null)
{
if (!string.IsNullOrWhiteSpace(skyboxRequest.ControlModel))
{
formData.AddField("control_model", skyboxRequest.ControlModel);
}
using var imageData = new MemoryStream();
await skyboxRequest.ControlImage.CopyToAsync(imageData, cancellationToken);
formData.AddBinaryData("control_image", imageData.ToArray(), skyboxRequest.ControlImageFileName);
skyboxRequest.Dispose();
}
var response = await Rest.PostAsync(GetUrl("skybox"), formData, parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
var skyboxInfo = JsonConvert.DeserializeObject<SkyboxInfo>(response.Body, client.JsonSerializationOptions);
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(pollingInterval ?? 3 * 1000, CancellationToken.None)
.ConfigureAwait(true); // Configure await to make sure we're still in Unity context
skyboxInfo = await GetSkyboxInfoAsync(skyboxInfo, CancellationToken.None);
if (skyboxInfo.Status is Status.Pending or Status.Processing or Status.Dispatched)
{
continue;
}
break;
}
if (cancellationToken.IsCancellationRequested)
{
var cancelResult = await CancelSkyboxGenerationAsync(skyboxInfo, CancellationToken.None);
if (!cancelResult)
{
throw new Exception($"Failed to cancel generation for {skyboxInfo.Id}");
}
}
cancellationToken.ThrowIfCancellationRequested();
if (skyboxInfo.Status != Status.Complete)
{
throw new Exception($"Failed to generate skybox! {skyboxInfo.Id} -> {skyboxInfo.Status}\nError: {skyboxInfo.ErrorMessage}\n{skyboxInfo}");
}
await skyboxInfo.LoadTexturesAsync(cancellationToken);
return skyboxInfo;
}
/// <summary>
/// Returns the skybox metadata for the given skybox id.
/// </summary>
/// <param name="id">Skybox Id.</param>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns><see cref="SkyboxInfo"/>.</returns>
public async Task< | SkyboxInfo> GetSkyboxInfoAsync(int id, CancellationToken cancellationToken = default)
{ |
var response = await Rest.GetAsync(GetUrl($"imagine/requests/{id}"), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
return JsonConvert.DeserializeObject<SkyboxInfoRequest>(response.Body, client.JsonSerializationOptions).SkyboxInfo;
}
/// <summary>
/// Deletes a skybox by id.
/// </summary>
/// <param name="id">The id of the skybox.</param>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns>True, if skybox was successfully deleted.</returns>
public async Task<bool> DeleteSkyboxAsync(int id, CancellationToken cancellationToken = default)
{
var response = await Rest.DeleteAsync(GetUrl($"imagine/deleteImagine/{id}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
const string successStatus = "Item deleted successfully";
if (skyboxOp is not { Success: successStatus })
{
throw new Exception($"Failed to cancel generation for skybox {id}!\n{skyboxOp?.Error}");
}
return skyboxOp.Success.Equals(successStatus);
}
/// <summary>
/// Gets the previously generated skyboxes.
/// </summary>
/// <param name="parameters">Optional, <see cref="SkyboxHistoryParameters"/>.</param>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns><see cref="SkyboxHistory"/>.</returns>
public async Task<SkyboxHistory> GetSkyboxHistoryAsync(SkyboxHistoryParameters parameters = null, CancellationToken cancellationToken = default)
{
var historyRequest = parameters ?? new SkyboxHistoryParameters();
var response = await Rest.GetAsync(GetUrl($"imagine/myRequests{historyRequest}"), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
return JsonConvert.DeserializeObject<SkyboxHistory>(response.Body, client.JsonSerializationOptions);
}
/// <summary>
/// Cancels a pending skybox generation request by id.
/// </summary>
/// <param name="id">The id of the skybox.</param>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
/// <returns>True, if generation was cancelled.</returns>
public async Task<bool> CancelSkyboxGenerationAsync(int id, CancellationToken cancellationToken = default)
{
var response = await Rest.DeleteAsync(GetUrl($"imagine/requests/{id}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
if (skyboxOp is not { Success: "true" })
{
throw new Exception($"Failed to cancel generation for skybox {id}!\n{skyboxOp?.Error}");
}
return skyboxOp.Success.Equals("true");
}
/// <summary>
/// Cancels ALL pending skybox generation requests.
/// </summary>
/// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
public async Task<bool> CancelAllPendingSkyboxGenerationsAsync(CancellationToken cancellationToken = default)
{
var response = await Rest.DeleteAsync(GetUrl("imagine/requests/pending"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
response.Validate();
var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
if (skyboxOp is not { Success: "true" })
{
if (skyboxOp != null &&
skyboxOp.Error.Contains("You don't have any pending"))
{
return false;
}
throw new Exception($"Failed to cancel all pending skybox generations!\n{skyboxOp?.Error}");
}
return skyboxOp.Success.Equals("true");
}
}
}
| BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/Skyboxes/SkyboxEndpoint.cs | RageAgainstThePixel-com.rest.blockadelabs-aa2142f | [
{
"filename": "BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/Skyboxes/SkyboxInfo.cs",
"retrieved_chunk": " [JsonProperty(\"error_message\")]\n public string ErrorMessage { get; set; }\n public override string ToString() => JsonConvert.SerializeObject(this, Formatting.Indented);\n public static implicit operator int(SkyboxInfo skyboxInfo) => skyboxInfo.Id;\n /// <summary>\n /// Loads the textures for this skybox.\n /// </summary>\n /// <param name=\"cancellationToken\">Optional, <see cref=\"CancellationToken\"/>.</param>\n public async Task LoadTexturesAsync(CancellationToken cancellationToken = default)\n {",
"score": 0.8458510637283325
},
{
"filename": "BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/Skyboxes/SkyboxRequest.cs",
"retrieved_chunk": " /// </param>\n /// <param name=\"remixImagineId\">\n /// ID of a previously generated skybox.\n /// </param>\n /// <param name=\"depth\">\n /// Return depth map image.\n /// </param>\n public SkyboxRequest(\n string prompt,\n string negativeText = null,",
"score": 0.7984157800674438
},
{
"filename": "BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/BlockadeLabsAuthentication.cs",
"retrieved_chunk": " /// </summary>\n /// <param name=\"apiKey\">The API key, required to access the API endpoint.</param>\n public BlockadeLabsAuthentication(string apiKey) => Info = new BlockadeLabsAuthInfo(apiKey);\n /// <summary>\n /// Instantiates a new Authentication object with the given <paramref name=\"authInfo\"/>, which may be <see langword=\"null\"/>.\n /// </summary>\n /// <param name=\"authInfo\"></param>\n public BlockadeLabsAuthentication(BlockadeLabsAuthInfo authInfo) => Info = authInfo;\n /// <inheritdoc />\n public override BlockadeLabsAuthInfo Info { get; }",
"score": 0.7948257327079773
},
{
"filename": "BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/Skyboxes/SkyboxRequest.cs",
"retrieved_chunk": " /// </param>\n /// <param name=\"remixImagineId\">\n /// ID of a previously generated skybox.\n /// </param>\n /// <param name=\"depth\">\n /// Return depth map image.\n /// </param>\n public SkyboxRequest(\n string prompt,\n Texture2D controlImage,",
"score": 0.7893546223640442
},
{
"filename": "BlockadeLabs/Packages/com.rest.blockadelabs/Runtime/Skyboxes/SkyboxRequest.cs",
"retrieved_chunk": " /// </param>\n /// <param name=\"controlImage\">\n /// <see cref=\"Stream\"/> data of control image for request.\n /// </param>\n /// <param name=\"controlImageFileName\">\n /// File name of <see cref=\"controlImage\"/>.\n /// </param>\n /// <param name=\"controlModel\">\n /// Model used for the <see cref=\"ControlImage\"/>.\n /// Currently the only option is: \"scribble\".",
"score": 0.7706615924835205
}
] | csharp | SkyboxInfo> GetSkyboxInfoAsync(int id, CancellationToken cancellationToken = default)
{ |
using HarmonyLib;
using Mono.Cecil;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using UnityEngine;
namespace Ultrapain.Patches
{
/*
u = initial, f = final, d = delta, s = speed multiplier
u = 40f * Time.deltaTime
f = 40f * S * Time.deltaTime
d = 40f * Time.deltaTime * (S - 1)
revCharge += 40f * Time.deltaTime * (S - 1f) * (alt ? 0.5f : 1f)
*/
class Revolver_Update
{
static bool Prefix(Revolver __instance)
{
if(__instance.gunVariation == 0 && __instance.pierceCharge < 100f)
{
__instance.pierceCharge = Mathf.Min(100f, __instance.pierceCharge + 40f * Time.deltaTime * (ConfigManager.chargedRevRegSpeedMulti.value - 1f) * (__instance.altVersion ? 0.5f : 1f));
}
return true;
}
}
public class Revolver_Shoot
{
public static void RevolverBeamEdit(RevolverBeam beam)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.revolverAltDamage.value : ConfigManager.revolverDamage.value;
}
public static void RevolverBeamSuperEdit(RevolverBeam beam)
{
if (beam.gunVariation == 0)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.chargedAltRevDamage.value : ConfigManager.chargedRevDamage.value;
beam.hitAmount = beam.strongAlt ? ConfigManager.chargedAltRevTotalHits.value : ConfigManager.chargedRevTotalHits.value;
beam.maxHitsPerTarget = beam.strongAlt ? ConfigManager.chargedAltRevMaxHitsPerTarget.value : ConfigManager.chargedRevMaxHitsPerTarget.value;
}
else if (beam.gunVariation == 2)
{
beam.damage -= beam.strongAlt ? 1.25f : 1f;
beam.damage += beam.strongAlt ? ConfigManager.sharpshooterAltDamage.value : ConfigManager.sharpshooterDamage.value;
beam.maxHitsPerTarget = beam.strongAlt ? ConfigManager.sharpshooterAltMaxHitsPerTarget.value : ConfigManager.sharpshooterMaxHitsPerTarget.value;
}
}
static FieldInfo f_RevolverBeam_gunVariation = typeof(RevolverBeam).GetField("gunVariation", UnityUtils.instanceFlag);
static MethodInfo m_Revolver_Shoot_RevolverBeamEdit = typeof(Revolver_Shoot).GetMethod("RevolverBeamEdit", UnityUtils.staticFlag);
static MethodInfo m_Revolver_Shoot_RevolverBeamSuperEdit = typeof(Revolver_Shoot).GetMethod("RevolverBeamSuperEdit", UnityUtils.staticFlag);
static MethodInfo m_GameObject_GetComponent_RevolverBeam = typeof(GameObject).GetMethod("GetComponent", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(RevolverBeam) });
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
object normalBeamLocalIndex = null;
object superBeamLocalIndex = null;
// Get local indexes of components for RevolverBeam references
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_GameObject_GetComponent_RevolverBeam))
{
object localIndex = ILUtils.GetLocalIndex(code[i + 1]);
if (localIndex == null)
continue;
if (normalBeamLocalIndex == null)
{
normalBeamLocalIndex = localIndex;
}
else
{
superBeamLocalIndex = localIndex;
break;
}
}
}
Debug.Log($"Normal beam index: {normalBeamLocalIndex}");
Debug.Log($"Super beam index: {superBeamLocalIndex}");
// Modify normal beam
for (int i = 3; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_RevolverBeam_gunVariation))
{
object localIndex = ILUtils.GetLocalIndex(code[i - 3]);
if (localIndex == null)
continue;
if (localIndex.Equals(normalBeamLocalIndex))
{
Debug.Log($"Patching normal beam");
i += 1;
code.Insert(i, ILUtils.LoadLocalInstruction(localIndex));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Revolver_Shoot_RevolverBeamEdit));
break;
}
}
}
// Modify super beam
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_RevolverBeam_gunVariation))
{
object localIndex = ILUtils.GetLocalIndex(code[i - 3]);
if (localIndex == null)
continue;
if (localIndex.Equals(superBeamLocalIndex))
{
Debug.Log($"Patching super beam");
i += 1;
code.Insert(i, ILUtils.LoadLocalInstruction(localIndex));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Revolver_Shoot_RevolverBeamSuperEdit));
break;
}
}
}
return code.AsEnumerable();
}
}
public class Shotgun_Shoot
{
public static void ModifyShotgunPellet(Projectile proj, Shotgun shotgun, int primaryCharge)
{
if (shotgun.variation == 0)
{
proj.damage = ConfigManager.shotgunBlueDamagePerPellet.value;
}
else
{
if (primaryCharge == 0)
proj.damage = ConfigManager.shotgunGreenPump1Damage.value;
else if (primaryCharge == 1)
proj.damage = ConfigManager.shotgunGreenPump2Damage.value;
else if (primaryCharge == 2)
proj.damage = ConfigManager.shotgunGreenPump3Damage.value;
}
}
public static void ModifyPumpExplosion(Explosion exp)
{
exp.damage = ConfigManager.shotgunGreenExplosionDamage.value;
exp.playerDamageOverride = ConfigManager.shotgunGreenExplosionPlayerDamage.value;
float sizeMulti = ConfigManager.shotgunGreenExplosionSize.value / 9f;
exp.maxSize *= sizeMulti;
exp.speed *= sizeMulti;
exp.speed *= ConfigManager.shotgunGreenExplosionSpeed.value;
}
static MethodInfo m_GameObject_GetComponent_Projectile = typeof(GameObject).GetMethod("GetComponent", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(Projectile) });
static MethodInfo m_GameObject_GetComponentsInChildren_Explosion = typeof(GameObject).GetMethod("GetComponentsInChildren", new Type[0], new ParameterModifier[0]).MakeGenericMethod(new Type[1] { typeof(Explosion) });
static MethodInfo m_Shotgun_Shoot_ModifyShotgunPellet = typeof(Shotgun_Shoot).GetMethod("ModifyShotgunPellet", UnityUtils.staticFlag);
static MethodInfo m_Shotgun_Shoot_ModifyPumpExplosion = typeof(Shotgun_Shoot).GetMethod("ModifyPumpExplosion", UnityUtils.staticFlag);
static FieldInfo f_Shotgun_primaryCharge = typeof(Shotgun).GetField("primaryCharge", UnityUtils.instanceFlag);
static FieldInfo f_Explosion_damage = typeof(Explosion).GetField("damage", UnityUtils.instanceFlag);
static bool Prefix(Shotgun __instance, int ___primaryCharge)
{
if (__instance.variation == 0)
{
__instance.spread = ConfigManager.shotgunBlueSpreadAngle.value;
}
else
{
if (___primaryCharge == 0)
__instance.spread = ConfigManager.shotgunGreenPump1Spread.value * 1.5f;
else if (___primaryCharge == 1)
__instance.spread = ConfigManager.shotgunGreenPump2Spread.value;
else if (___primaryCharge == 2)
__instance.spread = ConfigManager.shotgunGreenPump3Spread.value / 2f;
}
return true;
}
static void Postfix(Shotgun __instance)
{
__instance.spread = 10f;
}
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction pelletStoreInst = new CodeInstruction(OpCodes.Stloc_0);
int pelletCodeIndex = 0;
// Find pellet local variable index
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldc_I4_S && code[i].OperandIs(12))
{
if (ConfigManager.shotgunBluePelletCount.value > sbyte.MaxValue)
code[i].opcode = OpCodes.Ldc_I4;
code[i].operand = ConfigManager.shotgunBluePelletCount.value;
i += 1;
pelletCodeIndex = i;
pelletStoreInst = code[i];
break;
}
}
// Debug.Log($"Pellet store instruction: {ILUtils.TurnInstToString(pelletStoreInst)}");
// Modify pellet counts
for (int i = pelletCodeIndex + 1; i < code.Count; i++)
{
if (code[i].opcode == pelletStoreInst.opcode
&& (pelletStoreInst.operand == null ? true : pelletStoreInst.operand.Equals(code[i].operand))
&& ILUtils.IsConstI4LoadWithOperand(code[i - 1].opcode))
{
int constIndex = i - 1;
int pelletCount = ILUtils.GetI4LoadOperand(code[constIndex]);
if (pelletCount == 10)
pelletCount = ConfigManager.shotgunGreenPump1Count.value;
else if (pelletCount == 16)
pelletCount = ConfigManager.shotgunGreenPump2Count.value;
else if (pelletCount == 24)
pelletCount = ConfigManager.shotgunGreenPump3Count.value;
if (ILUtils.TryEfficientLoadI4(pelletCount, out OpCode efficientOpcode))
{
code[constIndex].operand = null;
code[constIndex].opcode = efficientOpcode;
}
else
{
if (pelletCount > sbyte.MaxValue)
code[constIndex].opcode = OpCodes.Ldc_I4;
else
code[constIndex].opcode = OpCodes.Ldc_I4_S;
code[constIndex].operand = pelletCount;
}
}
}
// Modify projectile damage
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_GameObject_GetComponent_Projectile))
{
i += 1;
// Duplicate component (arg 0)
code.Insert(i, new CodeInstruction(OpCodes.Dup));
i += 1;
// Add instance to stack (arg 1)
code.Insert(i, new CodeInstruction(OpCodes.Ldarg_0));
i += 1;
// Load instance then get primary field (arg 2)
code.Insert(i, new CodeInstruction(OpCodes.Ldarg_0));
i += 1;
code.Insert(i, new CodeInstruction(OpCodes.Ldfld, f_Shotgun_primaryCharge));
i += 1;
// Call the static method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_Shoot_ModifyShotgunPellet));
break;
}
}
// Modify pump explosion
int pumpExplosionIndex = 0;
while (code[pumpExplosionIndex].opcode != OpCodes.Callvirt && !code[pumpExplosionIndex].OperandIs(m_GameObject_GetComponentsInChildren_Explosion))
pumpExplosionIndex += 1;
for (int i = pumpExplosionIndex; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld)
{
if (code[i].OperandIs(f_Explosion_damage))
{
// Duplicate before damage assignment
code.Insert(i - 1, new CodeInstruction(OpCodes.Dup));
i += 2;
// Argument 0 already loaded, call the method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_Shoot_ModifyPumpExplosion));
// Stack is now clear
break;
}
}
}
return code.AsEnumerable();
}
}
// Core eject
class Shotgun_ShootSinks
{
public static void ModifyCoreEject(GameObject core)
{
GrenadeExplosionOverride ovr = core.AddComponent<GrenadeExplosionOverride>();
ovr.normalMod = true;
ovr.normalDamage = (float)ConfigManager.shotgunCoreExplosionDamage.value / 35f;
ovr.normalSize = (float)ConfigManager.shotgunCoreExplosionSize.value / 6f * ConfigManager.shotgunCoreExplosionSpeed.value;
ovr.normalPlayerDamageOverride = ConfigManager.shotgunCoreExplosionPlayerDamage.value;
ovr.superMod = true;
ovr.superDamage = (float)ConfigManager.shotgunCoreExplosionDamage.value / 35f;
ovr.superSize = (float)ConfigManager.shotgunCoreExplosionSize.value / 6f * ConfigManager.shotgunCoreExplosionSpeed.value;
ovr.superPlayerDamageOverride = ConfigManager.shotgunCoreExplosionPlayerDamage.value;
}
static FieldInfo f_Grenade_sourceWeapon = typeof(Grenade).GetField("sourceWeapon", UnityUtils.instanceFlag);
static MethodInfo m_Shotgun_ShootSinks_ModifyCoreEject = typeof(Shotgun_ShootSinks).GetMethod("ModifyCoreEject", UnityUtils.staticFlag);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Stfld && code[i].OperandIs(f_Grenade_sourceWeapon))
{
i += 1;
// Add arg 0
code.Insert(i, new CodeInstruction(OpCodes.Dup));
i += 1;
// Call mod method
code.Insert(i, new CodeInstruction(OpCodes.Call, m_Shotgun_ShootSinks_ModifyCoreEject));
break;
}
}
return code.AsEnumerable();
}
}
class Nailgun_Shoot
{
static FieldInfo f_Nailgun_heatSinks = typeof(Nailgun).GetField("heatSinks", UnityUtils.instanceFlag);
static FieldInfo f_Nailgun_heatUp = typeof(Nailgun).GetField("heatUp", UnityUtils.instanceFlag);
public static void ModifyNail( | Nailgun inst, GameObject nail)
{ |
Nail comp = nail.GetComponent<Nail>();
if (inst.altVersion)
{
// Blue saw launcher
if (inst.variation == 1)
{
comp.damage = ConfigManager.sawBlueDamage.value;
comp.hitAmount = ConfigManager.sawBlueHitAmount.value;
}
// Green saw launcher
else
{
comp.damage = ConfigManager.sawGreenDamage.value;
float maxHit = ConfigManager.sawGreenHitAmount.value;
float heatSinks = (float)f_Nailgun_heatSinks.GetValue(inst);
float heatUp = (float)f_Nailgun_heatUp.GetValue(inst);
if (heatSinks >= 1)
comp.hitAmount = Mathf.Lerp(maxHit, Mathf.Max(1f, maxHit), (maxHit - 2f) * heatUp);
else
comp.hitAmount = 1f;
}
}
else
{
// Blue nailgun
if (inst.variation == 1)
{
comp.damage = ConfigManager.nailgunBlueDamage.value;
}
else
{
if (comp.heated)
comp.damage = ConfigManager.nailgunGreenBurningDamage.value;
else
comp.damage = ConfigManager.nailgunGreenDamage.value;
}
}
}
static FieldInfo f_Nailgun_nail = typeof(Nailgun).GetField("nail", UnityUtils.instanceFlag);
static MethodInfo m_Nailgun_Shoot_ModifyNail = typeof(Nailgun_Shoot).GetMethod("ModifyNail", UnityUtils.staticFlag);
static MethodInfo m_Transform_set_forward = typeof(Transform).GetProperty("forward", UnityUtils.instanceFlag).GetSetMethod();
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction localObjectStoreInst = null;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && code[i].OperandIs(f_Nailgun_nail))
{
for (; i < code.Count; i++)
if (ILUtils.IsStoreLocalOpcode(code[i].opcode))
break;
localObjectStoreInst = code[i];
}
}
Debug.Log($"Nail local reference: {ILUtils.TurnInstToString(localObjectStoreInst)}");
int insertIndex = 0;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Callvirt && code[i].OperandIs(m_Transform_set_forward))
{
insertIndex = i + 1;
break;
}
}
// Push instance reference
code.Insert(insertIndex, new CodeInstruction(OpCodes.Ldarg_0));
insertIndex += 1;
// Push local nail object
code.Insert(insertIndex, new CodeInstruction(ILUtils.GetLoadLocalFromStoreLocal(localObjectStoreInst.opcode), localObjectStoreInst.operand));
insertIndex += 1;
// Call the method
code.Insert(insertIndex, new CodeInstruction(OpCodes.Call, m_Nailgun_Shoot_ModifyNail));
return code.AsEnumerable();
}
}
class Nailgun_SuperSaw
{
public static void ModifySupersaw(GameObject supersaw)
{
Nail saw = supersaw.GetComponent<Nail>();
saw.damage = ConfigManager.sawGreenBurningDamage.value;
saw.hitAmount = ConfigManager.sawGreenBurningHitAmount.value;
}
static FieldInfo f_Nailgun_heatedNail = typeof(Nailgun).GetField("heatedNail", UnityUtils.instanceFlag);
static MethodInfo m_Nailgun_SuperSaw_ModifySupersaw = typeof(Nailgun_SuperSaw).GetMethod("ModifySupersaw", UnityUtils.staticFlag);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
CodeInstruction localObjectStoreInst = null;
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && code[i].OperandIs(f_Nailgun_heatedNail))
{
for (; i < code.Count; i++)
if (ILUtils.IsStoreLocalOpcode(code[i].opcode))
break;
localObjectStoreInst = code[i];
}
}
Debug.Log($"Supersaw local reference: {ILUtils.TurnInstToString(localObjectStoreInst)}");
int insertIndex = code.Count - 1;
// Push local nail object
code.Insert(insertIndex, new CodeInstruction(ILUtils.GetLoadLocalFromStoreLocal(localObjectStoreInst.opcode), localObjectStoreInst.operand));
insertIndex += 1;
// Call the method
code.Insert(insertIndex, new CodeInstruction(OpCodes.Call, m_Nailgun_SuperSaw_ModifySupersaw));
return code.AsEnumerable();
}
}
class NailGun_Update
{
static bool Prefix(Nailgun __instance, ref float ___heatSinks)
{
if(__instance.variation == 0)
{
float maxSinks = (__instance.altVersion ? 1f : 2f);
float multi = (__instance.altVersion ? ConfigManager.sawHeatsinkRegSpeedMulti.value : ConfigManager.nailgunHeatsinkRegSpeedMulti.value);
float rate = 0.125f;
if (___heatSinks < maxSinks && multi != 1)
___heatSinks = Mathf.Min(maxSinks, ___heatSinks + Time.deltaTime * rate * (multi - 1f));
}
return true;
}
}
class NewMovement_Update
{
static bool Prefix(NewMovement __instance, int ___difficulty)
{
if (__instance.boostCharge < 300f && !__instance.sliding && !__instance.slowMode)
{
float multi = 1f;
if (___difficulty == 1)
multi = 1.5f;
else if (___difficulty == 0f)
multi = 2f;
__instance.boostCharge = Mathf.Min(300f, __instance.boostCharge + Time.deltaTime * 70f * multi * (ConfigManager.staminaRegSpeedMulti.value - 1f));
}
return true;
}
}
class WeaponCharges_Charge
{
static bool Prefix(WeaponCharges __instance, float __0)
{
if (__instance.rev1charge < 400f)
__instance.rev1charge = Mathf.Min(400f, __instance.rev1charge + 25f * __0 * (ConfigManager.coinRegSpeedMulti.value - 1f));
if (__instance.rev2charge < 300f)
__instance.rev2charge = Mathf.Min(300f, __instance.rev2charge + (__instance.rev2alt ? 35f : 15f) * __0 * (ConfigManager.sharpshooterRegSpeedMulti.value - 1f));
if(!__instance.naiAmmoDontCharge)
{
if (__instance.naiAmmo < 100f)
__instance.naiAmmo = Mathf.Min(100f, __instance.naiAmmo + __0 * 3.5f * (ConfigManager.nailgunAmmoRegSpeedMulti.value - 1f)); ;
if (__instance.naiSaws < 10f)
__instance.naiSaws = Mathf.Min(10f, __instance.naiSaws + __0 * 0.5f * (ConfigManager.sawAmmoRegSpeedMulti.value - 1f));
}
if (__instance.raicharge < 5f)
__instance.raicharge = Mathf.Min(5f, __instance.raicharge + __0 * 0.25f * (ConfigManager.railcannonRegSpeedMulti.value - 1f));
if (!__instance.rocketFrozen && __instance.rocketFreezeTime < 5f)
__instance.rocketFreezeTime = Mathf.Min(5f, __instance.rocketFreezeTime + __0 * 0.5f * (ConfigManager.rocketFreezeRegSpeedMulti.value - 1f));
if (__instance.rocketCannonballCharge < 1f)
__instance.rocketCannonballCharge = Mathf.Min(1f, __instance.rocketCannonballCharge + __0 * 0.125f * (ConfigManager.rocketCannonballRegSpeedMulti.value - 1f));
return true;
}
}
class NewMovement_GetHurt
{
static bool Prefix(NewMovement __instance, out float __state)
{
__state = __instance.antiHp;
return true;
}
static void Postfix(NewMovement __instance, float __state)
{
float deltaAnti = __instance.antiHp - __state;
if (deltaAnti <= 0)
return;
deltaAnti *= ConfigManager.hardDamagePercent.normalizedValue;
__instance.antiHp = __state + deltaAnti;
}
static FieldInfo hpField = typeof(NewMovement).GetField("hp");
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && (FieldInfo)code[i].operand == hpField)
{
i += 1;
if (code[i].opcode == OpCodes.Ldc_I4_S)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == (Single)99f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.maxPlayerHp.value - 1));
}
}
return code.AsEnumerable();
}
}
class HookArm_FixedUpdate
{
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 66f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(66f * (ConfigManager.maxPlayerHp.value / 100f) * ConfigManager.whiplashHardDamageSpeed.value));
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 50f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.whiplashHardDamageCap.value));
}
}
return code.AsEnumerable();
}
}
class NewMovement_ForceAntiHP
{
static FieldInfo hpField = typeof(NewMovement).GetField("hp");
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
if (code[i].opcode == OpCodes.Ldfld && (FieldInfo)code[i].operand == hpField)
{
i += 1;
if (i < code.Count && code[i].opcode == OpCodes.Ldc_I4_S && (SByte)code[i].operand == (SByte)100)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
else if (code[i].opcode == OpCodes.Ldarg_1)
{
i += 2;
if (i < code.Count && code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 99f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)(ConfigManager.maxPlayerHp.value - 1));
}
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 100f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)ConfigManager.maxPlayerHp.value);
}
else if (code[i].opcode == OpCodes.Ldc_R4 && (Single)code[i].operand == 50f)
{
code[i] = new CodeInstruction(OpCodes.Ldc_R4, (Single)ConfigManager.maxPlayerHp.value / 2);
}
else if (code[i].opcode == OpCodes.Ldc_I4_S && (SByte)code[i].operand == (SByte)100)
{
code[i] = new CodeInstruction(OpCodes.Ldc_I4, (Int32)ConfigManager.maxPlayerHp.value);
}
}
return code.AsEnumerable();
}
}
class NewMovement_GetHealth
{
static bool Prefix(NewMovement __instance, int __0, bool __1, ref AudioSource ___greenHpAud, Canvas ___fullHud)
{
if (__instance.dead || __instance.exploded)
return false;
int maxHp = Mathf.RoundToInt(ConfigManager.maxPlayerHp.value - __instance.antiHp);
int maxDelta = maxHp - __instance.hp;
if (maxDelta <= 0)
return true;
if (!__1 && __0 > 5 && MonoSingleton<PrefsManager>.Instance.GetBoolLocal("bloodEnabled", false))
{
GameObject.Instantiate<GameObject>(__instance.scrnBlood, ___fullHud.transform);
}
__instance.hp = Mathf.Min(maxHp, __instance.hp + __0);
__instance.hpFlash.Flash(1f);
if (!__1 && __0 > 5)
{
if (___greenHpAud == null)
{
___greenHpAud = __instance.hpFlash.GetComponent<AudioSource>();
}
___greenHpAud.Play();
}
return false;
}
}
class NewMovement_SuperCharge
{
static bool Prefix(NewMovement __instance)
{
__instance.hp = Mathf.Max(ConfigManager.maxPlayerHp.value, ConfigManager.playerHpSupercharge.value);
return false;
}
}
class NewMovement_Respawn
{
static void Postfix(NewMovement __instance)
{
__instance.hp = ConfigManager.maxPlayerHp.value;
}
}
class NewMovement_DeltaHpComp : MonoBehaviour
{
public static NewMovement_DeltaHpComp instance;
private NewMovement player;
private AudioSource hurtAud;
private bool levelMap = false;
private void Awake()
{
instance = this;
player = NewMovement.Instance;
hurtAud = player.hurtScreen.GetComponent<AudioSource>();
levelMap = SceneHelper.CurrentLevelNumber > 0;
UpdateEnabled();
}
public void UpdateEnabled()
{
if (!ConfigManager.playerHpDeltaToggle.value)
enabled = false;
if (SceneHelper.CurrentScene == "uk_construct")
enabled = ConfigManager.playerHpDeltaSandbox.value;
else if (SceneHelper.CurrentScene == "Endless")
enabled = ConfigManager.playerHpDeltaCybergrind.value;
else
{
enabled = SceneHelper.CurrentLevelNumber > 0;
}
}
public void ResetCooldown()
{
deltaCooldown = ConfigManager.playerHpDeltaDelay.value;
}
public float deltaCooldown = ConfigManager.playerHpDeltaDelay.value;
public void Update()
{
if (player.dead || !ConfigManager.playerHpDeltaToggle.value || !StatsManager.Instance.timer)
{
ResetCooldown();
return;
}
if (levelMap)
{
// Calm
if (MusicManager.Instance.requestedThemes == 0)
{
if (!ConfigManager.playerHpDeltaCalm.value)
{
ResetCooldown();
return;
}
}
// Combat
else
{
if (!ConfigManager.playerHpDeltaCombat.value)
{
ResetCooldown();
return;
}
}
}
deltaCooldown = Mathf.MoveTowards(deltaCooldown, 0f, Time.deltaTime);
if (deltaCooldown == 0f)
{
ResetCooldown();
int deltaHp = ConfigManager.playerHpDeltaAmount.value;
int limit = ConfigManager.playerHpDeltaLimit.value;
if (deltaHp == 0)
return;
if (deltaHp > 0)
{
if (player.hp > limit)
return;
player.GetHealth(deltaHp, true);
}
else
{
if (player.hp < limit)
return;
if (player.hp - deltaHp <= 0)
player.GetHurt(-deltaHp, false, 0, false, false);
else
{
player.hp += deltaHp;
if (ConfigManager.playerHpDeltaHurtAudio.value)
{
hurtAud.pitch = UnityEngine.Random.Range(0.8f, 1f);
hurtAud.PlayOneShot(hurtAud.clip);
}
}
}
}
}
}
class NewMovement_Start
{
static void Postfix(NewMovement __instance)
{
__instance.gameObject.AddComponent<NewMovement_DeltaHpComp>();
__instance.hp = ConfigManager.maxPlayerHp.value;
}
}
class HealthBarTracker : MonoBehaviour
{
public static List<HealthBarTracker> instances = new List<HealthBarTracker>();
private HealthBar hb;
private void Awake()
{
if (hb == null)
hb = GetComponent<HealthBar>();
instances.Add(this);
for (int i = instances.Count - 1; i >= 0; i--)
{
if (instances[i] == null)
instances.RemoveAt(i);
}
}
private void OnDestroy()
{
if (instances.Contains(this))
instances.Remove(this);
}
public void SetSliderRange()
{
if (hb == null)
hb = GetComponent<HealthBar>();
if (hb.hpSliders.Length != 0)
{
hb.hpSliders[0].maxValue = hb.afterImageSliders[0].maxValue = ConfigManager.maxPlayerHp.value;
hb.hpSliders[1].minValue = hb.afterImageSliders[1].minValue = ConfigManager.maxPlayerHp.value;
hb.hpSliders[1].maxValue = hb.afterImageSliders[1].maxValue = Mathf.Max(ConfigManager.maxPlayerHp.value, ConfigManager.playerHpSupercharge.value);
hb.antiHpSlider.maxValue = ConfigManager.maxPlayerHp.value;
}
}
}
class HealthBar_Start
{
static void Postfix(HealthBar __instance)
{
__instance.gameObject.AddComponent<HealthBarTracker>().SetSliderRange();
}
}
class HealthBar_Update
{
static FieldInfo f_HealthBar_hp = typeof(HealthBar).GetField("hp", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static FieldInfo f_HealthBar_antiHp = typeof(HealthBar).GetField("antiHp", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> code = new List<CodeInstruction>(instructions);
for (int i = 0; i < code.Count; i++)
{
CodeInstruction inst = code[i];
if (inst.opcode == OpCodes.Ldc_R4 && code[i - 1].OperandIs(f_HealthBar_hp))
{
float operand = (Single)inst.operand;
if (operand == 30f)
code[i].operand = (Single)(ConfigManager.maxPlayerHp.value * 0.3f);
else if (operand == 50f)
code[i].operand = (Single)(ConfigManager.maxPlayerHp.value * 0.5f);
}
else if (inst.opcode == OpCodes.Ldstr)
{
string operand = (string)inst.operand;
if (operand == "/200")
code[i].operand = $"/{ConfigManager.playerHpSupercharge}";
}
else if (inst.opcode == OpCodes.Ldc_R4 && i + 2 < code.Count && code[i + 2].OperandIs(f_HealthBar_antiHp))
{
code[i].operand = (Single)ConfigManager.maxPlayerHp.value;
}
}
return code.AsEnumerable();
}
}
}
| Ultrapain/Patches/PlayerStatTweaks.cs | eternalUnion-UltraPain-ad924af | [
{
"filename": "Ultrapain/Patches/V2Second.cs",
"retrieved_chunk": " //readonly static FieldInfo maliciousIgnorePlayer = typeof(RevolverBeam).GetField(\"maliciousIgnorePlayer\", BindingFlags.NonPublic | BindingFlags.Instance);\n Transform shootPoint;\n public Transform v2trans;\n public float cooldown = 0f;\n static readonly string debugTag = \"[V2][MalCannonShoot]\";\n void Awake()\n {\n shootPoint = UnityUtils.GetChildByNameRecursively(transform, \"Shootpoint\");\n }\n void PrepareFire()",
"score": 0.809278130531311
},
{
"filename": "Ultrapain/Patches/Turret.cs",
"retrieved_chunk": " else\n flag.shootCountRemaining = ConfigManager.turretBurstFireCount.value;\n return true;\n }\n }\n class TurretAim\n {\n static void Postfix(Turret __instance)\n {\n TurretFlag flag = __instance.GetComponent<TurretFlag>();",
"score": 0.7842259407043457
},
{
"filename": "Ultrapain/Patches/Cerberus.cs",
"retrieved_chunk": " ___eid.health -= ConfigManager.cerberusParryDamage.value;\n MonoSingleton<FistControl>.Instance.currentPunch.Parry(false, ___eid);\n return true;\n }\n }\n class StatueBoss_StopDash_Patch\n {\n public static void Postfix(StatueBoss __instance, ref int ___tackleChance)\n {\n CerberusFlag flag = __instance.GetComponent<CerberusFlag>();",
"score": 0.782871425151825
},
{
"filename": "Ultrapain/ConfigManager.cs",
"retrieved_chunk": " public Sprite sprite;\n public Color color;\n public ConfigField field;\n private GameObject currentUI;\n private Image currentImage;\n private static FieldInfo f_IntField_currentUi = typeof(IntField).GetField(\"currentUi\", UnityUtils.instanceFlag);\n private static FieldInfo f_FloatField_currentUi = typeof(FloatField).GetField(\"currentUi\", UnityUtils.instanceFlag);\n private static FieldInfo f_StringField_currentUi = typeof(StringField).GetField(\"currentUi\", UnityUtils.instanceFlag);\n private const float textAnchorX = 40f;\n private const float fieldAnchorX = 230f;",
"score": 0.7786181569099426
},
{
"filename": "Ultrapain/Patches/Solider.cs",
"retrieved_chunk": " //counter.remainingShots = ConfigManager.soliderShootCount.value;\n }\n }\n class Grenade_Explode_Patch\n {\n static bool Prefix(Grenade __instance, out bool __state)\n {\n __state = false;\n SoliderGrenadeFlag flag = __instance.GetComponent<SoliderGrenadeFlag>();\n if (flag == null)",
"score": 0.7735965847969055
}
] | csharp | Nailgun inst, GameObject nail)
{ |
using Newtonsoft.Json;
namespace DotNetDevBadgeWeb.Model
{
public class UserSummary
{
[JsonProperty("likes_given")]
public int LikesGiven { get; set; }
[JsonProperty("likes_received")]
public int LikesReceived { get; set; }
[JsonProperty("topics_entered")]
public int TopicsEntered { get; set; }
[JsonProperty("posts_read_count")]
public int PostsReadCount { get; set; }
[JsonProperty("days_visited")]
public int DaysVisited { get; set; }
[JsonProperty("topic_count")]
public int TopicCount { get; set; }
[JsonProperty("post_count")]
public int PostCount { get; set; }
[JsonProperty("time_read")]
public int TimeRead { get; set; }
[JsonProperty("recent_time_read")]
public int RecentTimeRead { get; set; }
[JsonProperty("bookmark_count")]
public int BookmarkCount { get; set; }
[ | JsonProperty("can_see_summary_stats")]
public bool CanSeeSummaryStats { | get; set; }
[JsonProperty("solved_count")]
public int SolvedCount { get; set; }
}
}
| src/dotnetdev-badge/dotnetdev-badge.web/Model/UserSummary.cs | chanos-dev-dotnetdev-badge-5740a40 | [
{
"filename": "src/dotnetdev-badge/dotnetdev-badge.web/Model/User.cs",
"retrieved_chunk": " public string Username { get; set; }\n [JsonProperty(\"name\")]\n public string Name { get; set; }\n [JsonProperty(\"avatar_template\")]\n public string AvatarTemplate { get; set; }\n [JsonProperty(\"flair_name\")]\n public object FlairName { get; set; }\n [JsonProperty(\"trust_level\")]\n public int TrustLevel { get; set; }\n [JsonProperty(\"admin\")]",
"score": 0.853378415107727
},
{
"filename": "src/dotnetdev-badge/dotnetdev-badge.web/Model/User.cs",
"retrieved_chunk": "using DotNetDevBadgeWeb.Common;\nusing Newtonsoft.Json;\nnamespace DotNetDevBadgeWeb.Model\n{\n public class User\n {\n private const int AVATAR_SIZE = 128;\n [JsonProperty(\"id\")]\n public int Id { get; set; }\n [JsonProperty(\"username\")]",
"score": 0.7258871793746948
},
{
"filename": "src/dotnetdev-badge/dotnetdev-badge.web/Model/User.cs",
"retrieved_chunk": " public bool? Admin { get; set; }\n [JsonProperty(\"moderator\")]\n public bool? Moderator { get; set; }\n public ELevel Level => TrustLevel switch\n {\n 3 => ELevel.Silver,\n 4 => ELevel.Gold,\n _ => ELevel.Bronze,\n };\n public string AvatarEndPoint => AvatarTemplate?.Replace(\"{size}\", AVATAR_SIZE.ToString()) ?? string.Empty;",
"score": 0.7033436894416809
},
{
"filename": "src/dotnetdev-badge/dotnetdev-badge.web/Interfaces/IProvider.cs",
"retrieved_chunk": "using DotNetDevBadgeWeb.Model;\nnamespace DotNetDevBadgeWeb.Interfaces\n{\n public interface IProvider\n {\n Task<(UserSummary summary, User user)> GetUserInfoAsync(string id, CancellationToken token);\n Task<(byte[] avatar, UserSummary summary, User user)> GetUserInfoWithAvatarAsync(string id, CancellationToken token);\n Task<(int gold, int silver, int bronze)> GetBadgeCountAsync(string id, CancellationToken token);\n }\n}",
"score": 0.6922858953475952
},
{
"filename": "src/dotnetdev-badge/dotnetdev-badge.web/Common/Palette.cs",
"retrieved_chunk": " _ => \"CD7F32\",\n };\n }\n internal class ColorSet\n {\n internal string FontColor { get; private set; }\n internal string BackgroundColor { get; private set; }\n internal ColorSet(string fontColor, string backgroundColor)\n {\n FontColor = fontColor;",
"score": 0.6700301170349121
}
] | csharp | JsonProperty("can_see_summary_stats")]
public bool CanSeeSummaryStats { |