public static Attribute[] GetAttributes(this ParameterKind kind)
{
switch (kind)
{
case ParameterKind.Optional:
return(new Attribute[] { new OptionalAttribute() });
case ParameterKind.Rest:
return(new Attribute[] { new RestAttribute() });
case ParameterKind.Block:
return(new Attribute[] { new BlockAttribute() });
case ParameterKind.KeyRequired:
return(new Attribute[] { new KeyAttribute() });
case ParameterKind.KeyOptional:
return(new Attribute[] { new KeyAttribute(), new OptionalAttribute() });
case ParameterKind.KeyRest:
return(new Attribute[] { new KeyAttribute(), new RestAttribute() });
default:
return(Array.Empty <Attribute>());
}
}
public static void AppendParameterKind(this CSharpColorizer colorizer, ParameterKind parameterKind)
{
switch (parameterKind)
{
case ParameterKind.VALUE:
colorizer.AppendPlainText("value");
return;
case ParameterKind.REFERENCE:
colorizer.AppendKeyword("ref");
return;
case ParameterKind.OUTPUT:
colorizer.AppendKeyword("out");
return;
case ParameterKind.INPUT:
colorizer.AppendKeyword("in");
return;
default:
colorizer.AppendPlainText("value");
return;
}
}
public string getLevelupText(ParameterKind kind)
{
switch (kind)
{
case ParameterKind.STRENGTH:
return(string.Format("物理攻撃のダメージ倍率{0}%→{1}%", 100 + strength * 40, 100 + (strength + 1) * 40));
case ParameterKind.INTELLIGENCE:
return(string.Format("魔法攻撃のダメージ倍率{0}%→{1}%", 100 + intelligence * 40, 100 + (intelligence + 1) * 40));
case ParameterKind.MAGICCAPACITY:
return(string.Format("最大MP{0}→{1}, Lv3以上でターン終了時のMP回復量UP", 100 + magicCapacity * 40, 100 + (magicCapacity + 1) * 40));
case ParameterKind.SPEED:
return(string.Format("すべての行動のWTを{0}%→{1}%カット", 100 - 100 * BattleCharacter.getDefaultWaitTimeCutRate(speed), 100 - 100 * BattleCharacter.getDefaultWaitTimeCutRate(speed + 1)));
case ParameterKind.DEFENCE:
return(string.Format("物理ダメージカット{0}%→{1}%,防御時さらに{2}%→{3}%のダメージを軽減",
100 * BattleCharacter.getDefaultNormalCutRate(defence),
100 * BattleCharacter.getDefaultNormalCutRate(defence + 1),
100 * BattleCharacter.getDefaultDefenceCutRate(defence),
100 * BattleCharacter.getDefaultDefenceCutRate(defence + 1)
));
case ParameterKind.VITALITY:
return(string.Format("最大HP{0}→{1}", 100 + vitality * 40, 100 + (vitality + 1) * 40));
default:
return("");
}
}
public int getLevelupCost(ParameterKind kind)
{
int level = 0;
switch (kind)
{
case ParameterKind.STRENGTH:
level = strength;
break;
case ParameterKind.INTELLIGENCE:
level = intelligence;
break;
case ParameterKind.MAGICCAPACITY:
level = magicCapacity;
break;
case ParameterKind.SPEED:
level = speed;
break;
case ParameterKind.DEFENCE:
level = defence;
break;
case ParameterKind.VITALITY:
level = vitality;
break;
}
return((level * level * 2 + 2) * 50);
}
public ParamInfo(ParameterKind kind, string name, Type type, DestructuredPropertyInfo[] destructuredProperties)
{
Kind = kind;
Name = name;
Type = type;
DestructuredProperties = destructuredProperties;
}
public ParameterDoc(string name, NameInfo parameterType = null,
ParameterKind parameterKind = ParameterKind.In, string description = null)
{
Name = name;
ParameterType = parameterType;
ParameterKind = parameterKind;
Description = description;
}
public Argument(string name, ParameterKind kind, Expression valueValueExpression, Expression typeExpression, Node location)
{
Name = name;
Kind = kind;
ValueExpression = valueValueExpression;
TypeExpression = typeExpression;
Location = location;
}
public CommandArgument(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string description,
TypeConverterAttribute converter, CommandArgumentAttribute argument)
: base(parameterType, parameterKind, property, description, converter, argument.IsRequired)
{
Value = argument.Value;
Position = argument.Position;
}
public CommandArgument(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string description,
TypeConverterAttribute converter, CommandArgumentAttribute argument, IEnumerable <ParameterValidationAttribute> validators)
: base(parameterType, parameterKind, property, description, converter, validators, argument.IsRequired)
{
Value = argument.ValueName;
Position = argument.Position;
}
public Argument(string name, ParameterKind kind, Expression valueValueExpression, IPythonType type, Node location)
{
Name = name;
Kind = kind;
Type = type;
ValueExpression = valueValueExpression;
Location = location;
}
public ParamInfo(PopulatedType type, string name = null, ParameterKind parameterKind = default)
{
Type = type;
Name = name ?? string.Empty;
ParameterKind = parameterKind;
_stringified = Stringify();
}
public override void SetParameter <T>(
int index, string parameterName, ParameterKind parameterKind, string typeName, T value, IFormatter <T> formatter)
{
StringBuilder.Append('[');
StringBuilder.Append(parameterKind.ToString());
StringBuilder.Append(']', ' ');
base.SetParameter(index, parameterName, parameterKind, typeName, value, formatter);
}
/// <nodoc />
public Parameter(SymbolAtom parameterName, Type parameterType, ParameterKind parameterKind, LineInfo location)
: base(location)
{
Contract.Requires(parameterName.IsValid || parameterType != null);
ParameterName = parameterName;
ParameterType = parameterType;
ParameterKind = parameterKind;
}
public Entry(ParameterKind kind, Func <Entry, string> factory)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
_factory = factory;
_kind = kind;
}
/// <nodoc />
public Parameter(DeserializationContext context, LineInfo location)
: base(location)
{
var reader = context.Reader;
ParameterName = reader.ReadSymbolAtom();
ParameterType = ReadType(context);
ParameterKind = (ParameterKind)reader.ReadByte();
}
public Parameter(Type type, string name, ParameterKind kind, Expression defaultValue = null)
{
Type = type;
Name = new Symbol(name);
Kind = kind;
DefaultValue = defaultValue;
Param = Parameter(type, name);
Local = Variable(typeof(LocalVariable), $"localVariable«{name}»");
}
public CommandOption(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string description,
TypeConverterAttribute converter, CommandOptionAttribute optionAttribute, DefaultValueAttribute defaultValue)
: base(parameterType, parameterKind, property, description, converter, optionAttribute.IsRequired)
{
LongName = optionAttribute.LongName;
ShortName = optionAttribute.ShortName;
ValueName = optionAttribute.ValueName;
DefaultValue = defaultValue;
}
public FSharpMethodParameter(FSharpParameter fsParam, [NotNull] IParametersOwner parametersOwner,
int parameterIndex, ParameterKind kind, IType type, string name)
{
FSharpSymbol = fsParam;
Type = type;
Kind = kind;
ShortName = name;
myParametersOwner = parametersOwner;
myParameterIndex = parameterIndex;
}
public void levelUp(ParameterKind kind)
{
int cost = getLevelupCost(kind);
if (cost > gold)
{
Debug.Log("払えないよ");
return;
}
if (getLevel(kind) >= 5)
{
Debug.Log("もうマックスだよ");
return;
}
gold -= cost;
totalGoldConsumed += cost;
switch (kind)
{
case ParameterKind.STRENGTH:
strength++;
break;
case ParameterKind.INTELLIGENCE:
intelligence++;
break;
case ParameterKind.MAGICCAPACITY:
magicCapacity++;
break;
case ParameterKind.SPEED:
speed++;
break;
case ParameterKind.DEFENCE:
defence++;
break;
case ParameterKind.VITALITY:
vitality++;
break;
}
//パラメータ直接上昇系のやつは増えた分を即時反映
if (kind == ParameterKind.MAGICCAPACITY)
{
refreshParameters();
healMp(40);
}
if (kind == ParameterKind.VITALITY)
{
refreshParameters();
healHp(40);
}
}
protected CommandParameter(
Type parameterType, ParameterKind parameterKind, PropertyInfo property,
string description, TypeConverterAttribute converter, bool required)
{
ParameterType = parameterType;
ParameterKind = parameterKind;
Property = property;
Description = description;
Converter = converter;
Required = required;
}
public CommandOption(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string description,
TypeConverterAttribute converter, CommandOptionAttribute optionAttribute,
IEnumerable <ParameterValidationAttribute> validators, DefaultValueAttribute defaultValue)
: base(parameterType, parameterKind, property, description, converter, validators, false)
{
LongNames = optionAttribute.LongNames;
ShortNames = optionAttribute.ShortNames;
ValueName = optionAttribute.ValueName;
DefaultValue = defaultValue;
}
public CommandArgument(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string?description,
TypeConverterAttribute?converter, DefaultValueAttribute?defaultValue,
CommandArgumentAttribute argument, ParameterValueProviderAttribute?valueProvider,
IEnumerable <ParameterValidationAttribute> validators)
: base(parameterType, parameterKind, property, description, converter, defaultValue,
null, valueProvider, validators, argument.IsRequired, false)
{
Value = argument.ValueName;
Position = argument.Position;
}
public CommandOption(
Type parameterType, ParameterKind parameterKind, PropertyInfo property, string?description,
TypeConverterAttribute?converter, PairDeconstructorAttribute?deconstructor,
CommandOptionAttribute optionAttribute, IEnumerable <ParameterValidationAttribute> validators,
DefaultValueAttribute?defaultValue, bool valueIsOptional)
: base(parameterType, parameterKind, property, description, converter,
defaultValue, deconstructor, validators, false)
{
LongNames = optionAttribute.LongNames;
ShortNames = optionAttribute.ShortNames;
ValueName = optionAttribute.ValueName;
ValueIsOptional = valueIsOptional;
}
public override void SetParameter <T>(
int index, string parameterName, ParameterKind parameterKind, string typeName, T value, IFormatter <T> formatter)
{
base.SetParameter(index, parameterName, parameterKind, typeName, value, formatter);
// When the parameter is a business object, add it to the list of correlated business objects.
var businessObject = value as BusinessObject;
if (businessObject != null)
{
((ExtendedAuditRecord)CurrentRecord).RelatedBusinessObjects.Add(businessObject);
}
}
protected CommandParameter(
Type parameterType, ParameterKind parameterKind, PropertyInfo property,
string description, TypeConverterAttribute converter,
IEnumerable <ParameterValidationAttribute> validators, bool required)
{
ParameterType = parameterType;
ParameterKind = parameterKind;
Property = property;
Description = description;
Converter = converter;
Validators = new List <ParameterValidationAttribute>(validators ?? Array.Empty <ParameterValidationAttribute>());
Required = required;
}
public void NumericMax(string parameterName, decimal value, ParameterKind kind = ParameterKind.Numeric)
{
lock (_statistics)
{
Entry entry;
if (!_statistics.TryGetValue(parameterName, out entry))
{
_statistics.Add(parameterName, new Entry(kind, e => Display(e, _statisticsNumeric[parameterName])));
_statisticsNumeric[parameterName] = 0;
}
_statisticsNumeric[parameterName] = Math.Max(_statisticsNumeric[parameterName], value);
}
}
public void NumericSum(string parameterName, decimal value, ParameterKind kind = ParameterKind.Numeric)
{
lock (_statistics)
{
Entry entry;
if (!_statistics.TryGetValue(parameterName, out entry))
{
_statistics.Add(parameterName, new Entry(kind, e => Display(e, _statisticsNumeric[parameterName])));
_statisticsNumeric.Add(parameterName, value);
}
else
{
_statisticsNumeric[parameterName] += value;
}
}
}
public static void AppendParameterKind([NotNull] this CSharpColorizer colorizer, ParameterKind parameterKind) {
switch (parameterKind) {
case ParameterKind.VALUE:
colorizer.AppendPlainText("value");
return;
case ParameterKind.REFERENCE:
colorizer.AppendKeyword("ref");
return;
case ParameterKind.OUTPUT:
colorizer.AppendKeyword("out");
return;
default:
colorizer.AppendPlainText("value");
return;
}
}
protected CommandParameter(
Type parameterType, ParameterKind parameterKind, PropertyInfo property,
string?description, TypeConverterAttribute?converter,
DefaultValueAttribute?defaultValue,
PairDeconstructorAttribute?deconstuctor,
IEnumerable <ParameterValidationAttribute> validators, bool required)
{
Id = Guid.NewGuid();
ParameterType = parameterType;
ParameterKind = parameterKind;
Property = property;
Description = description;
Converter = converter;
DefaultValue = defaultValue;
PairDeconstructor = deconstuctor;
Validators = new List <ParameterValidationAttribute>(validators ?? Array.Empty <ParameterValidationAttribute>());
Required = required;
}
public void ShouldGetNameForIParameter(string parameterName,
string typeName,
string assemblyName,
string assemblyVersion,
ParameterKind pKind,
bool isOptional,
bool isParameterArray,
string identifier)
{
var paramMock = new Mock <IParameter>();
paramMock.Setup(p => p.ShortName).Returns(parameterName);
paramMock.Setup(p => p.Type).Returns(TypeMockUtils.MockIType(typeName, assemblyName, assemblyVersion));
paramMock.Setup(p => p.Kind).Returns(pKind);
paramMock.Setup(p => p.IsOptional).Returns(isOptional);
paramMock.Setup(p => p.IsParameterArray).Returns(isParameterArray);
AssertName(paramMock.Object, Names.Parameter(identifier));
}
public void NumericAverrage(string parameterName, decimal value, ParameterKind kind = ParameterKind.Numeric)
{
lock (_statistics)
{
Entry entry;
if (!_statistics.TryGetValue(parameterName, out entry))
{
_statistics.Add(parameterName, new Entry(kind, e =>
Display(e, (_statisticsNumeric[parameterName + "__sum"] / _statisticsNumeric[parameterName + "__count"]))));
_statisticsNumeric[parameterName + "__sum"] = value;
_statisticsNumeric[parameterName + "__count"] = 1;
}
else
{
_statisticsNumeric[parameterName + "__sum"] += value;
_statisticsNumeric[parameterName + "__count"] += 1;
}
}
}
public Parameter(string name, ParameterKind kind)
: this(name, null)
{
_kind = kind;
}
/// <summary>
/// Creates a new <see cref="ParameterTypeMatchingInfo"/> matching the given parameter
/// type and kind.
/// </summary>
/// <param name="nameToMatch">Parameter <see cref="System.Type"/> name to match.</param>
/// <param name="ignoreCase">If false, compare type names using case-sensitive comparison.
/// If true, compare type names using case-insensitive comparison.</param>
/// <param name="kind"><see cref="ParameterKind"/> of parameter to match.</param>
public ParameterTypeMatchingInfo(string nameToMatch, bool ignoreCase, ParameterKind kind)
: base(nameToMatch, ignoreCase)
{
this.kind = kind;
}
/// <summary>
/// Creates a new <see cref="ParameterTypeMatchingInfo"/> matching the given parameter
/// type and kind.
/// </summary>
/// <param name="nameToMatch">Parameter <see cref="System.Type"/> name to match.</param>
/// <param name="kind"><see cref="ParameterKind"/> of parameter to match.</param>
public ParameterTypeMatchingInfo(string nameToMatch, ParameterKind kind)
: base(nameToMatch)
{
this.kind = kind;
}
/// <summary>
/// Creates a new <see cref="ParameterTypeMatchingInfo"/> matching the given kind of parameter.
/// </summary>
/// <param name="kind"><see cref="ParameterKind"/> of parameter to match.</param>
public ParameterTypeMatchingInfo(ParameterKind kind)
{
this.kind = kind;
}
public Parameter(string name, Expr defaultValue)
{
_name = name;
_defaultValue = defaultValue;
_kind = ParameterKind.Normal;
}
private Parameter ParseParameterName(Dictionary<SymbolId, object> names, ParameterKind kind) {
SymbolId name = ReadName();
if (name != SymbolId.Empty) {
CheckUniqueParameter(names, name);
} else {
return null;
}
Parameter parameter = new Parameter(name, kind);
parameter.SetLoc(GetStart(), GetEnd());
return parameter;
}
public VariableDef AddLocatedVariable(string name, Node location, AnalysisUnit unit, ParameterKind paramKind = ParameterKind.Normal) {
VariableDef value;
if (!TryGetVariable(name, out value)) {
VariableDef def;
switch (paramKind) {
case ParameterKind.List: def = new ListParameterVariableDef(unit, location); break;
case ParameterKind.Dictionary: def = new DictParameterVariableDef(unit, location); break;
default: def = new LocatedVariableDef(unit.DeclaringModule.ProjectEntry, location); break;
}
return AddVariable(name, def);
} else if (!(value is LocatedVariableDef)) {
VariableDef def;
switch (paramKind) {
case ParameterKind.List: def = new ListParameterVariableDef(unit, location, value); break;
case ParameterKind.Dictionary: def = new DictParameterVariableDef(unit, location, value); break;
default: def = new LocatedVariableDef(unit.DeclaringModule.ProjectEntry, location, value); break;
}
return AddVariable(name, def);
} else {
((LocatedVariableDef)value).Node = location;
((LocatedVariableDef)value).DeclaringVersion = unit.ProjectEntry.AnalysisVersion;
}
return value;
}
// parameter ::=
// identifier | "(" sublist ")"
private Parameter ParseParameter(int position, HashSet<string> names, ParameterKind kind, bool isTyped = false) {
Name name;
Parameter parameter;
if (PeekToken().Kind == TokenKind.LeftParenthesis) {
// sublist
string parenWhiteSpace = _lookaheadWhiteSpace;
NextToken();
var parenStart = GetStart();
Expression ret = ParseSublist(names, true);
if (_langVersion.Is3x()) {
ReportSyntaxError(parenStart, GetEnd(), "sublist parameters are not supported in 3.x");
}
bool ateRightParen = Eat(TokenKind.RightParenthesis);
string closeParenWhiteSpace = _tokenWhiteSpace;
TupleExpression tret = ret as TupleExpression;
NameExpression nameRet;
if (tret != null) {
parameter = new SublistParameter(position, tret);
if (_verbatim) {
AddPreceedingWhiteSpace(tret, parenWhiteSpace);
AddSecondPreceedingWhiteSpace(tret, closeParenWhiteSpace);
if (!ateRightParen) {
AddErrorMissingCloseGrouping(parameter);
}
}
} else if ((nameRet = ret as NameExpression) != null) {
parameter = new Parameter(nameRet.Name, kind);
if (_verbatim) {
AddThirdPreceedingWhiteSpace(parameter, (string)_attributes[nameRet][NodeAttributes.PreceedingWhiteSpace]);
AddIsAltForm(parameter);
if (!ateRightParen) {
AddErrorMissingCloseGrouping(parameter);
}
}
} else {
Debug.Assert(ret is ErrorExpression);
ReportSyntaxError(_lookahead);
parameter = new ErrorParameter((ErrorExpression)ret);
AddIsAltForm(parameter);
}
if (parameter != null) {
parameter.SetLoc(ret.IndexSpan);
}
if (_verbatim) {
AddPreceedingWhiteSpace(parameter, parenWhiteSpace);
AddSecondPreceedingWhiteSpace(parameter, closeParenWhiteSpace);
if (!ateRightParen) {
AddErrorMissingCloseGrouping(parameter);
}
}
} else if ((name = TokenToName(PeekToken())).HasName) {
NextToken();
var paramStart = GetStart();
parameter = new Parameter(name.RealName, kind);
if (_verbatim) {
AddPreceedingWhiteSpace(parameter, _tokenWhiteSpace);
AddVerbatimName(name, parameter);
}
if (isTyped && MaybeEat(TokenKind.Colon)) {
if (_verbatim) {
AddThirdPreceedingWhiteSpace(parameter, _tokenWhiteSpace);
}
var start = GetStart();
parameter.Annotation = ParseExpression();
if (_langVersion.Is2x()) {
ReportSyntaxError(start, parameter.Annotation.EndIndex, "invalid syntax, parameter annotations require 3.x");
}
}
CompleteParameterName(parameter, name.RealName, names, paramStart);
} else {
ReportSyntaxError(_lookahead);
NextToken();
parameter = new ErrorParameter(_verbatim ? Error(_tokenWhiteSpace + _token.Token.VerbatimImage) : null);
}
return parameter;
}
private Parameter ParseParameterName(HashSet<string> names, ParameterKind kind, bool isTyped = false) {
var start = GetStart();
var name = ReadName();
string nameWhiteSpace = _tokenWhiteSpace;
if (name.RealName != null) {
CheckUniqueParameter(start, names, name.RealName);
} else {
return null;
}
Parameter parameter = new Parameter(name.RealName, kind);
if (_verbatim) {
AddSecondPreceedingWhiteSpace(parameter, nameWhiteSpace);
AddVerbatimName(name, parameter);
}
parameter.SetLoc(GetStart(), GetEnd());
start = GetStart();
if (isTyped && MaybeEat(TokenKind.Colon)) {
string colonWhiteSpace = _tokenWhiteSpace;
if (_langVersion.Is2x()) {
ReportSyntaxError(start, GetEnd(), "invalid syntax, parameter annotations require 3.x");
}
parameter.Annotation = ParseExpression();
if (_verbatim) {
AddThirdPreceedingWhiteSpace(parameter, colonWhiteSpace);
}
}
return parameter;
}
public string Format(ParameterKind parameterKind)
{
throw new NotImplementedException();
}
public Parameter(SymbolId name, ParameterKind kind) {
_name = name;
_kind = kind;
}
private static Action<Parameter> CheckParameter(string name, ParameterKind kind = ParameterKind.Normal, Action<Expression> defaultValue = null, Action<Expression> annotation = null) {
return param => {
Assert.AreEqual(name, param.Name);
Assert.AreEqual(kind, param.Kind);
if (defaultValue != null) {
defaultValue(param.DefaultValue);
} else {
Assert.AreEqual(null, param.DefaultValue);
}
if (annotation != null) {
annotation(param.Annotation);
} else {
Assert.AreEqual(null, param.Annotation);
}
};
}
///<summary>
///
/// Returns language specific presentation for a given parameter kind
///
///</summary>
///
public string Format(ParameterKind parameterKind)
{
throw new NotSupportedException();
}
private Parameter ParseParameterName(Dictionary<string, object> names, ParameterKind kind) {
string name = ReadName();
if (name != null) {
CheckUniqueParameter(names, name);
} else {
return null;
}
Parameter parameter = new Parameter(name, kind);
parameter.SetLoc(GetStart(), GetEnd());
return parameter;
}
public string Format(ParameterKind parameterKind)
{
return String.Empty;
}
public Parameter(string name, ParameterKind kind) {
_name = name ?? "";
_kind = kind;
}
private Parameter ParseParameterName(HashSet<string> names, ParameterKind kind) {
string name = ReadName();
if (name != null) {
CheckUniqueParameter(names, name);
} else {
return null;
}
Parameter parameter = new Parameter(name, kind);
parameter.SetLoc(_globalParent, GetStart(), GetEnd());
return parameter;
}
private Parameter ParseParameterName(HashSet<string> names, ParameterKind kind)
{
string name = ReadName();
int start = GetStart(),
end = GetEnd();
if (name != null)
CheckUniqueParameter(names, name);
else
return null;
Parameter parameter = new Parameter(name, kind);
parameter.SetLoc(_globalParent, GetStart(), GetEnd());
if (_sink != null)
_sink.StartName(
new SourceSpan(
_tokenizer.IndexToLocation(start),
_tokenizer.IndexToLocation(end)
),
name
);
return parameter;
}