/// <summary>
/// Generates the attack of the fighter.
/// </summary>
/// <returns>
/// Attack type
/// </returns>
public virtual Attack GenAttack()
{
//Fighter opponent
//int a = 10;
Attack attk;
Random rnd = new Random();
if (rnd.Next(0, 3) == 0)
{
attk = new Punch();
}
else if (rnd.Next(0, 3) == 1)
{
attk = new Kick();
}
else
{
attk = new Special();
}
//return attack
Attack = attk;
return(attk);
}
public void UseServiceInitialize()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserSimpleInjectorRegistration>()
.IncludeAssemblyFor <UserServiceModule>()
.UseSimpleInjector(s => s.Initialize(c => c.Options.AllowOverridingRegistrations = true))
);
Kick.ServiceProvider.Should().NotBeNull();
Kick.ServiceProvider.Should().BeOfType <Container>();
var userService = Kick.ServiceProvider.GetService <IUserService>();
userService.Should().NotBeNull();
userService.Connection.Should().NotBeNull();
userService.Connection.Should().BeOfType <SampleConnection>();
var vehicleService = Kick.ServiceProvider.GetService <IVehicle>();
vehicleService.Should().NotBeNull();
vehicleService.Should().BeOfType <DeliveryVehicle>();
var minivanService = Kick.ServiceProvider.GetService <IMinivan>();
minivanService.Should().NotBeNull();
minivanService.Should().BeOfType <DeliveryVehicle>();
}
/// <summary>
/// Replace the equipped Kick with a new one, return the kick replaced
/// </summary>
/// <param name="newKick">The kick that will be replacing the old one</param>
/// <returns></returns>
public Kick ReplaceCurrentKick(Kick newKick)
{
Kick previousKick = currentKick;
currentKick = newKick;
return(previousKick);
}
// Use this for initialization
void Start()
{
if (kickScript == null)
{
kickScript = gameObject.GetComponent <Kick>();
}
}
public void ConfigureData()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.Data("name", "value")
.Data(d =>
{
d["key"] = 123;
d["enviroment"] = "debug";
})
.IncludeAssemblyFor <TestStartup>()
.UseStartupTask(c =>
{
c.Run((services, data) =>
{
data.Should().ContainKey("name");
data.Should().ContainKey("key");
data.Should().ContainKey("enviroment");
data["enviroment"].Should().Be("debug");
data["passed"] = "yes";
});
c.Run((services, data) =>
{
data.Should().ContainKey("name");
data.Should().ContainKey("key");
data.Should().ContainKey("enviroment");
data["enviroment"].Should().Be("debug");
data["passed"].Should().Be("yes");
});
})
);
}
public void Configure()
{
Kick.Start(config => config
.IncludeAssemblyFor <TestStartup>()
.UseStartupTask()
);
}
public void UseAutofacBuilderLogTo()
{
string defaultEmail = "*****@*****.**";
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserModule>()
.UseAutofac(c => c
.Initialize(b => b
.Register(x => new Employee {
EmailAddress = defaultEmail
}
))
)
);
Kick.ServiceProvider.Should().NotBeNull();
Kick.ServiceProvider.Should().BeOfType <AutofacServiceProvider>();
var repo = Kick.ServiceProvider.GetService <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
var employee = Kick.ServiceProvider.GetService <Employee>();
employee.Should().NotBeNull();
employee.EmailAddress.Should().Be(defaultEmail);
}
void Start()
{
NewRound();
KickInfo = Ball.GetComponent <Kick>();
BallRB = Ball.GetComponent <Rigidbody>();
GameAudio = GetComponent <AudioSource>();
}
}/// <summary>
/// <summary>
/// Create an action node which is Kick attack type.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="AI">The ai.</param>
/// <param name="NAI">The nai.</param>
/// <returns>MyTreeBuilder</returns>
/// <exception cref="System.ApplicationException">Can't create an unnested ActionNode, it must be a leaf node.</exception>
public MyTreeBuilder Kick(GameWorld context, AIFighter AI, NonAIFighter NAI)
{
if (parentNodeStack.Count <= 0)
{
throw new ApplicationException("Can't create an unnested ActionNode, it must be a leaf node.");
}
Func <MyTimeData, MyBehaviourTreeStatus> fr;
fr = t =>
{
// A Kick attack
Kick kick = new Kick();
GameWorld gw = context;
gw.wAttack(AI, NAI, kick);
gw.ListOfEvents.Add("Kick non AI player");
return(MyBehaviourTreeStatus.Success);
};
var actionNone = new ActionNode("Kick", fr);
parentNodeStack.Peek().AddChild(actionNone);
return(this);
}
public void ConfigureUseContainer()
{
Kick.Start(config => config
.IncludeAssemblyFor <TestStartup>()
.UseStartupTask(c => c.UseContainer())
);
}
/// <summary>
/// /////////////////////////////////////////////////
/// </summary>
/// <param name="chat_id"></param>
/// <param name="user_Id"></param>
/// <returns></returns>
///
/*
* public static async Task<ResponseData> SetQuizGroup(SetQuizRequest request)
* {
* if (request == null) return null;
* try
* {
* string url = "https://kyc.jarvisplus.io/qna/setQnaGroup";
* using (var client = new HttpClient())
* {
* var response = await client.PostAsJsonAsync(url, request).ConfigureAwait(false);
* string result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
* if (response.IsSuccessStatusCode)
* {
* ResponseData resdata = null;
* try
* {
* resdata = (ResponseData)JsonConvert.DeserializeObject(result, typeof(ResponseData));
* }
* catch (Exception ex)
* {
* Debug.WriteLine(ex.ToString());
* }
* return resdata;
*
* }
*
* else
* return null;
* }
* }
* catch
* {
* return null;
* }
* }
*/
public async Task <string> kickChatMember(int chat_id, int user_Id)
{
//string s = @"{""file_id"":" + "\"" + response + "\"}"
//string s = @"{""chat_id"":" + "\"" + chat_id + "\"," + @"""user_id"":" + "\"" + user_Id + "\"}";
Kick kick = new Kick();
kick.chat_id = chat_id;
kick.user_id = user_Id;
// HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url + "kickChatMember");
try
{
//string url = "https://kyc.jarvisplus.io/qna/setQnaGroup";
using (var client = new HttpClient())
{
var response = await client.PostAsJsonAsync(url + "kickChatMember", kick).ConfigureAwait(false);
var result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return(true.ToString());
}
else
{
return(false.ToString());
}
}
}
catch (Exception e)
{
return(e.ToString());
}
}
public void UseAutofacBuilderLogTo()
{
string defaultEmail = "*****@*****.**";
var _logs = new List <LogData>();
Kick.Start(config => config
.IncludeAssemblyFor <UserModule>()
.UseAutofac(c => c
.Builder(b => b
.Register(x => new Employee {
EmailAddress = defaultEmail
}
))
)
.LogTo(_logs.Add)
);
Kick.Container.Should().NotBeNull();
Kick.Container.Should().BeOfType <AutofacAdaptor>();
Kick.Container.As <IContainer>().Should().BeOfType <Container>();
var repo = Kick.Container.Resolve <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
var employee = Kick.Container.Resolve <Employee>();
employee.Should().NotBeNull();
employee.EmailAddress.Should().Be(defaultEmail);
_logs.Should().NotBeEmpty();
}
public override int ProcessKick(Kick protocol)
{
App.Instance.LinkdService.ReportError(
protocol.Argument.Linksid, Linkd.BReportError.FromProvider,
protocol.Argument.Code, protocol.Argument.Desc);
return(Zeze.Transaction.Procedure.Success);
}
private void Start()
{
_walk = new Walk();
_jump = new Jump();
_kick = new Kick();
_punch = new Punch();
_animator = player.GetComponent <Animator>();
}
private int kick()
{
var multi = getAttackMultiplier();
var increase = getAttackModifier();
var kick = new Kick();
return(kick.Action(Strength, Crit, multi, increase));
}
public void Configure()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <TestStartup>()
.UseStartupTask()
);
}
private void Listener_OnKick(User user, string channel, string kickee, string reason)
{
var chan = _channels[channel];
Kick.Fire(this, new KickEventArgs(user, chan, kickee, reason));
chan.UserKick(user, kickee, reason);
Connection.Sender.Names(channel);
}
private void SendKick(Zeze.Net.AsyncSocket sender, long linkSid, int code, string desc)
{
var p = new Kick();
p.Argument.Linksid = linkSid;
p.Argument.Code = code;
p.Argument.Desc = desc;
p.Send(sender);
}
public async Task LogKickAsync(IUser target, CachedGuild guild, Kick kick)
{
using var ctx = new AdminDatabaseContext(_provider);
var guildConfig = await ctx.GetOrCreateGuildAsync(guild.Id);
if (!guildConfig.Settings.HasFlag(GuildSettings.Punishments))
{
return;
}
var moderator = guild.CurrentMember as IUser;
if (kick is null)
{
if (!guildConfig.Settings.HasFlag(GuildSettings.AutoPunishments) || KickedUserIds.Remove(target.Id))
{
return;
}
string reason = null;
// TODO: Adjust delay if necessary.
await Task.Delay(TimeSpan.FromSeconds(1));
var logs = await guild.GetAuditLogsAsync <RestMemberKickedAuditLog>(5);
if (logs.OrderByDescending(x => x.Id).FirstOrDefault(x => x.TargetId == target.Id) is { } log)
{
moderator = await log.ResponsibleUser.DownloadAsync();
reason = log.Reason;
}
kick = new Kick(guild.Id, target.Id, moderator.Id, reason);
ctx.Punishments.Add(kick);
await ctx.SaveChangesAsync();
}
else
{
moderator = await _client.GetOrDownloadUserAsync(kick.ModeratorId);
}
if (await ctx.GetLoggingChannelAsync(guild.Id, LogType.Kick) is CachedTextChannel logChannel)
{
var message =
await SendLoggingEmbedAsync(kick, target, moderator, null, logChannel, guildConfig.Language);
kick.SetLogMessage(message);
ctx.Punishments.Update(kick);
await ctx.SaveChangesAsync();
}
var user = await ctx.GetOrCreateGlobalUserAsync(target.Id);
await SendTargetEmbedAsync(kick, target, null, user.Language);
}
public void Configure()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <OrderProfile>()
.UseEntityChange()
);
var original = new Order
{
Id = Guid.NewGuid().ToString(),
OrderNumber = 1000,
Total = 10000,
};
var current = new Order
{
Id = Guid.NewGuid().ToString(),
OrderNumber = 1000,
Total = 11000,
Items = new List <OrderLine>
{
new OrderLine {
Sku = "abc-123", Quanity = 1, UnitPrice = 5000
},
}
};
var comparer = new EntityComparer();
var changes = comparer.Compare(original, current);
changes.Should().NotBeNull();
changes.Count.Should().Be(3);
var total = changes.FirstOrDefault(c => c.Path == "Total");
total.Should().NotBeNull();
total.Path.Should().Be("Total");
total.CurrentFormatted.Should().Be("$11,000.00");
var items = changes.FirstOrDefault(c => c.Path == "Items[0]");
items.Should().NotBeNull();
items.Path.Should().Be("Items[0]");
items.CurrentFormatted.Should().Be("abc-123");
items.Operation.Should().Be(ChangeOperation.Add);
WriteMarkdown(changes);
}
private Tetromino(string name, ConsoleColor color, Kick kicks, char[,,] input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
// Data is assumed to be in an in code array initializer order
var rotationCount = input.GetLength(0);
Height = input.GetLength(1);
Width = input.GetLength(2);
Kicks = kicks ?? throw new ArgumentNullException(nameof(kicks));
Color = color;
Name = name;
// Create storage for each rotation
_rotations = new Grid <BlockState> [rotationCount];
// Construct each rotation
for (var o = 0; o < rotationCount; o++)
{
// Create grid to store current rotation
var grid = _rotations[o] = new Grid <BlockState>(Width, Height);
// Mark appropriate blocks as solid
foreach (var(x, y) in grid.GetCoordinates())
{
// Mark each block as solid
grid[x, y] = input[o, y, x] == ' '
? BlockState.Empty
: BlockState.Solid;
}
// Detect blocks as shadow casters
foreach (var(x, y) in grid.GetCoordinates())
{
// If current block is solid
if (grid[x, y].HasFlag(BlockState.Solid))
{
// Valid coordinate and is not solid or is not valid (off bottom edge)
if ((grid.Contains(x, y + 1) && grid[x, y + 1] == BlockState.Empty) || !grid.Contains(x, y + 1))
{
grid[x, y] |= BlockState.Shadow;
}
}
}
}
}
public void Game()
{
Random rnd = new Random();
int magicNumber = rnd.Next(0, 10);
if (magicNumber > 2)
{
Console.WriteLine("Ping получил Pong");
Kick?.Invoke();
}
else
{
Console.WriteLine("Pong промахнулся, победил Ping");
}
}
public void UseDependencyInjection()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserDependencyInjectionRegistration>()
.UseDependencyInjection()
);
Kick.ServiceProvider.Should().NotBeNull();
var repo = Kick.ServiceProvider.GetService <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
}
public void UseAutofac()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserModule>()
.UseAutofac()
);
Kick.ServiceProvider.Should().NotBeNull();
Kick.ServiceProvider.Should().BeOfType <AutofacServiceProvider>();
var repo = Kick.ServiceProvider.GetService <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
}
public void UseUnity()
{
Kick.Start(config => config
.IncludeAssemblyFor <User>()
.UseUnity()
);
Kick.Container.Should().NotBeNull();
Kick.Container.Should().BeOfType <UnityAdaptor>();
Kick.Container.As <IUnityContainer>().Should().BeOfType <UnityContainer>();
var repo = Kick.Container.Resolve <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
}
public void UseNinject()
{
Kick.Start(config => config
.IncludeAssemblyFor <User>()
.UseNinject()
);
Kick.Container.Should().NotBeNull();
Kick.Container.Should().BeOfType <NinjectAdaptor>();
Kick.Container.As <IKernel>().Should().BeOfType <StandardKernel>();
var repo = Kick.Container.Resolve <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
}
/// <summary>
/// Configure and run the KickStart extensions.
/// </summary>
/// <param name="services"></param>
/// <param name="configurator">The <see langword="delegate"/> to configure KickStart before execution of the extensions.</param>
/// <example>Configure KickStart to use startup tasks.
/// <code><![CDATA[
/// services.KickStart(config => config
/// .IncludeAssemblyFor<Startup>()
/// .UseStartupTask()
/// );]]></code>
/// </example>
public static IServiceCollection KickStart(this IServiceCollection services, Action <IConfigurationBuilder> configurator)
{
var serviceProvider = services.BuildServiceProvider();
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
var logger = loggerFactory?.CreateLogger(typeof(Kick));
Kick.Start(builder =>
{
builder
.LogTo(m => logger?.LogDebug(m))
.UseDependencyInjection(d => d.Creator(() => services));
configurator?.Invoke(builder);
});
return(services);
}
public void UseNinject()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserNinjectModule>()
.UseNinject()
);
Kick.ServiceProvider.Should().NotBeNull();
Kick.ServiceProvider.Should().BeOfType <StandardKernel>();
Kick.ServiceProvider.As <IKernel>().Should().BeOfType <StandardKernel>();
var repo = Kick.ServiceProvider.GetService <IUserRepository>();
repo.Should().NotBeNull();
repo.Should().BeOfType <UserRepository>();
}
public void Configure()
{
Kick.Start(config => config
.IncludeAssemblyFor <UserMap>()
.UseMongoDB()
);
var isMapped = BsonClassMap.IsClassMapRegistered(typeof(User));
isMapped.Should().BeTrue();
var map = BsonClassMap.LookupClassMap(typeof(User));
map.Should().NotBeNull();
map.IdMemberMap.Should().NotBeNull();
map.IdMemberMap.MemberName.Should().Be("Id");
}
public void UseServiceInitialize()
{
Kick.Start(config => config
.LogTo(_output.WriteLine)
.IncludeAssemblyFor <UserUnityRegistration>()
.UseUnity()
);
Kick.ServiceProvider.Should().NotBeNull();
Kick.ServiceProvider.Should().BeOfType <UnityServiceProvider>();
var userService = Kick.ServiceProvider.GetService <IUserService>();
userService.Should().NotBeNull();
userService.Connection.Should().NotBeNull();
userService.Connection.Should().BeOfType <SampleConnection>();
}
protected override void Action(Kick kick) {
String reason = kick.Scope.Content != null ? kick.Scope.Content.FirstOrDefault() : String.Empty;
foreach (Player player in kick.Scope.Players) {
this.Send(String.IsNullOrEmpty(reason) == false ? this.CreatePacket("clientkick {0} \"{1}\"", player.SlotId, reason) : this.CreatePacket("clientkick {0}", player.SlotId));
}
}
