/***
* Converts all the JunimoHuts in the Farm from FromType to ToType
***/
private static void ConvertJunimoHuts <FromType, ToType>() where ToType : JunimoHut where FromType : JunimoHut
{
Farm f = Game1.getFarm();
List <Building> buildings = f.buildings;
for (int i = 0; i < buildings.Count; i++)
{
if (buildings[i] is FromType)
{
FromType oldHut = (buildings[i] as FromType);
//Kill all junimos before removing the building.
foreach (JunimoHarvester harvester in oldHut.myJunimos)
{
f.characters.Remove(harvester);
}
oldHut.myJunimos.Clear();
ToType newHut = (ToType)Activator.CreateInstance(typeof(ToType), new object[] { new BluePrint("Junimo Hut"), new Vector2(oldHut.tileX, oldHut.tileY) });
newHut.daysOfConstructionLeft = oldHut.daysOfConstructionLeft;
newHut.output = oldHut.output;
buildings[i] = newHut;
}
}
}
/// <summary>
/// Deploys this instance.
/// </summary>
public void Deploy(PropertyMapGenerationOptions __options = PropertyMapGenerationOptions.none)
{
if (__options != PropertyMapGenerationOptions.none)
{
Options = __options;
}
if (FromType.hasParameterlessConstructor())
{
FromDefaultInstance = FromType.getInstance(null);
}
if (ToType.hasParameterlessConstructor())
{
ToDefaultInstance = ToType.getInstance(null);
}
if (Options.HasFlag(PropertyMapGenerationOptions.doAutoMapping))
{
// fromProps.Select(x => toProps.ContainsKey(x.Key));
if (Options.HasFlag(PropertyMapGenerationOptions.matchName))
{
List <String> matchFromList = fromProps.Keys.Where(x => toProps.ContainsKey(x)).ToList();
foreach (var k in matchFromList)
{
PropertyMapLink link = PropertyMapLink.Create(fromProps[k], toProps[k], this);
if (link != null)
{
Links.Add(link);
}
}
}
}
}
public string Save <T>(DayReport <T> report, ToType toType) where T : Interfaces.Reports.IReport
{
if (toType != DefaultType)
{
// need for report
ImplementSave(report, DefaultType);
}
return(ImplementSave(report, toType));
}
public IEnumerable <Comment> GetLastCreate(ToType type, int limit)
{
var query = Query <Comment> .EQ(e => e.To_Type, (int)type);
var results = this.MongoConnectionHandler.MongoCollection.FindAs <Comment>(query)
.SetSortOrder(SortBy <Comment> .Descending(g => g.CreateDate))
.SetLimit(limit);
return(results);
}
private void CalcHashCode()
{
unchecked
{
_hashCode = 639348056;
_hashCode = _hashCode * -1521134295 + (ToType == null ? 0 : ToType.GetHashCode());
_hashCode = _hashCode * -1521134295 + (FieldType == null ? 0 : FieldType.GetHashCode());
_hashCode = _hashCode * -1521134295 + (ProviderFieldType == null ? 0 : ProviderFieldType.GetHashCode());
_hashCode = _hashCode * -1521134295 + (DataTypeName == null ? 0 : DataTypeName.GetHashCode());
}
}
private Interfaces.Files.IInteraction GetPath(ToType toType, DateTime time)
{
switch (toType)
{
case ToType.ToDoList:
case ToType.JSON:
case ToType.XML:
default:
return(new Files.Ordinary(Settings.Default.GetLaborFullPath(time, $"{FileName}.{toType.GetAttributeDescription()}")));
}
}
private string ImplementSave <T>(DayReport <T> report, ToType toType) where T : Interfaces.Reports.IReport
{
var formatter = DefineReportFormat <T>(toType);
formatter.Add(report);
var requested = GetPath(toType, report.Date);
BarrierManager.Save(requested, formatter.Serialize());
return(requested.Path);
}
public async Task <bool> ShareAsync(string fileId, string sessionId, ToType toType)
{
string url = $"api/entities/{fileId}/share";
var req = new
{
ref_id = sessionId,
ref_type = toType
};
var res = await WtHttpClient.PutAsync <ApiDataResponse <bool> >(url, req);
return(res.Code == 200 && res.Data);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Id;
hashCode = (hashCode * 397) ^ StartDate.GetHashCode();
hashCode = (hashCode * 397) ^ EndDate.GetHashCode();
hashCode = (hashCode * 397) ^ FromType.GetHashCode();
hashCode = (hashCode * 397) ^ ToType.GetHashCode();
hashCode = (hashCode * 397) ^ (FromValue != null ? StringComparer.InvariantCultureIgnoreCase.GetHashCode(FromValue) : 0);
hashCode = (hashCode * 397) ^ (ToValue != null ? StringComparer.InvariantCultureIgnoreCase.GetHashCode(ToValue) : 0);
hashCode = (hashCode * 397) ^ (TimeAndDows != null ? TimeAndDows.GetHashCode() : 0);
return(hashCode);
}
}
private Interfaces.Reports.IReportFormatter <T> DefineReportFormat <T>(ToType toType) where T : Interfaces.Reports.IReport
{
switch (toType)
{
case ToType.ToDoList:
return(new To.TodoList <T>());
case ToType.XML:
return(new To.XMLReport <T>());
case ToType.JSON:
return(new To.JsonReport <T>());
default:
return(new To.TodoList <T>());
}
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset._from)
{
hashcode = (hashcode * 397) + _from.GetHashCode();
}
if (__isset.to)
{
hashcode = (hashcode * 397) + To.GetHashCode();
}
if (__isset.toType)
{
hashcode = (hashcode * 397) + ToType.GetHashCode();
}
if (__isset.id)
{
hashcode = (hashcode * 397) + Id.GetHashCode();
}
if (__isset.createdTime)
{
hashcode = (hashcode * 397) + CreatedTime.GetHashCode();
}
if (__isset.deliveredTime)
{
hashcode = (hashcode * 397) + DeliveredTime.GetHashCode();
}
if (__isset.text)
{
hashcode = (hashcode * 397) + Text.GetHashCode();
}
if (__isset.location)
{
hashcode = (hashcode * 397) + Location.GetHashCode();
}
if (__isset.hasContent)
{
hashcode = (hashcode * 397) + HasContent.GetHashCode();
}
if (__isset.contentType)
{
hashcode = (hashcode * 397) + ContentType.GetHashCode();
}
if (__isset.contentPreview)
{
hashcode = (hashcode * 397) + ContentPreview.GetHashCode();
}
if (__isset.contentMetadata)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(ContentMetadata);
}
if (__isset.sessionId)
{
hashcode = (hashcode * 397) + SessionId.GetHashCode();
}
if (__isset.chunks)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(Chunks);
}
if (__isset.relatedMessageId)
{
hashcode = (hashcode * 397) + RelatedMessageId.GetHashCode();
}
if (__isset.messageRelationType)
{
hashcode = (hashcode * 397) + MessageRelationType.GetHashCode();
}
if (__isset.readCount)
{
hashcode = (hashcode * 397) + ReadCount.GetHashCode();
}
if (__isset.relatedMessageServiceCode)
{
hashcode = (hashcode * 397) + RelatedMessageServiceCode.GetHashCode();
}
}
return(hashcode);
}
public override ILifetimeManager CloneWithGenericArguments(Type[] genericArguments)
{
var newToType = ToType.GetGenericTypeDefinition().MakeGenericType(genericArguments);
return(new PerScopeLifetimeManager(newToType, Scope, Factory));
}
protected virtual void DeployTypes()
{
fromProps = FromType.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToDictionary(x => x.Name);
toProps = ToType.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToDictionary(x => x.Name);
}
public override string ToString()
{
var sb = new StringBuilder("Message(");
bool __first = true;
if (_from != null && __isset._from)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("_from: ");
_from.ToString(sb);
}
if (To != null && __isset.to)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("To: ");
To.ToString(sb);
}
if (__isset.toType)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ToType: ");
ToType.ToString(sb);
}
if (Id != null && __isset.id)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Id: ");
Id.ToString(sb);
}
if (__isset.createdTime)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("CreatedTime: ");
CreatedTime.ToString(sb);
}
if (__isset.deliveredTime)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("DeliveredTime: ");
DeliveredTime.ToString(sb);
}
if (Text != null && __isset.text)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Text: ");
Text.ToString(sb);
}
if (Location != null && __isset.location)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Location: ");
Location.ToString(sb);
}
if (__isset.hasContent)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("HasContent: ");
HasContent.ToString(sb);
}
if (__isset.contentType)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ContentType: ");
ContentType.ToString(sb);
}
if (ContentPreview != null && __isset.contentPreview)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ContentPreview: ");
ContentPreview.ToString(sb);
}
if (ContentMetadata != null && __isset.contentMetadata)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ContentMetadata: ");
ContentMetadata.ToString(sb);
}
if (__isset.sessionId)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("SessionId: ");
SessionId.ToString(sb);
}
if (Chunks != null && __isset.chunks)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Chunks: ");
Chunks.ToString(sb);
}
if (RelatedMessageId != null && __isset.relatedMessageId)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("RelatedMessageId: ");
RelatedMessageId.ToString(sb);
}
if (__isset.messageRelationType)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("MessageRelationType: ");
MessageRelationType.ToString(sb);
}
if (__isset.readCount)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ReadCount: ");
ReadCount.ToString(sb);
}
if (__isset.relatedMessageServiceCode)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("RelatedMessageServiceCode: ");
RelatedMessageServiceCode.ToString(sb);
}
sb.Append(")");
return(sb.ToString());
}
private void ExecMtCommand_()
{
FromType from = Current_().GetFromType();
FuncType alu = Current_().GetFuncType();
ToType to = Current_().GetToType();
ShiftType shift = Current_().GetShiftType();
int a = Current_().GetRawValue(WordType.A);
int b = Current_().GetRawValue(WordType.B);
int d = Current_().GetRawValue(WordType.D);
prevRegQ_ = regQ_;
prevRegA_ = regCommon_[a];
prevRegB_ = regCommon_[b];
switch (from)
{
case FromType.A_AND_PQ:
r_ = regCommon_[a];
s_ = regQ_;
break;
case FromType.A_AND_B:
r_ = regCommon_[a];
s_ = regCommon_[b];
break;
case FromType.ZERO_AND_Q:
r_ = 0;
s_ = regQ_;
break;
case FromType.ZERO_AND_B:
r_ = 0;
s_ = regCommon_[b];
break;
case FromType.ZERO_AND_A:
r_ = 0;
s_ = regCommon_[a];
break;
case FromType.D_AND_A:
r_ = d;
s_ = regCommon_[a];
break;
case FromType.D_AND_Q:
r_ = d;
s_ = regQ_;
break;
case FromType.D_AND_ZERO:
r_ = d;
s_ = 0;
break;
}
switch (alu)
{
case FuncType.R_PLUS_S:
f_ = r_ + s_;
break;
case FuncType.R_PLUS_S_PLUS_1:
f_ = r_ + s_ + 1;
break;
case FuncType.S_MINUS_R_MINUS_1:
f_ = s_ + Helpers.Mask(~r_);
break;
case FuncType.S_MINUS_R:
f_ = s_ + Helpers.Mask(~r_) + 1;
break;
case FuncType.R_MINUS_S_MINUS_1:
f_ = r_ + Helpers.Mask(~s_);
break;
case FuncType.R_MINUS_S:
f_ = r_ + Helpers.Mask(~s_) + 1;
break;
case FuncType.R_OR_S:
f_ = r_ | s_;
break;
case FuncType.R_AND_S:
f_ = r_ & s_;
break;
case FuncType.NO_R_AND_S:
f_ = Helpers.Mask(~r_) & s_;
break;
case FuncType.R_XOR_S:
f_ = r_ ^ s_;
break;
case FuncType.R_EQ_S:
f_ = Helpers.Mask(~(r_ ^ s_));
break;
}
f_ = Helpers.Mask(f_);
CountFlags_(alu);
int qLow = Helpers.GetBit(regQ_, 0);
int qHigh = Helpers.GetBit(regQ_, Command.WORD_SIZE - 1);
int fLow = Helpers.GetBit(f_, 0);
int fHigh = Helpers.GetBit(f_, Command.WORD_SIZE - 1);
switch (to)
{
case ToType.F_IN_Q:
regQ_ = f_;
break;
case ToType.NO_LOAD:
break;
case ToType.F_IN_B_AND_A_IN_Y:
case ToType.F_IN_B:
regCommon_[b] = f_;
break;
case ToType.SR_F_IN_B_AND_SR_Q_IN_Q:
regQ_ = regQ_ >> 1;
regCommon_[b] = f_ >> 1;
switch (shift)
{
case ShiftType.CYCLE:
regCommon_[b] |= fLow << 3;
regQ_ |= qLow << 3;
break;
case ShiftType.CYCLE_DOUBLE:
regCommon_[b] |= qLow << 3;
regQ_ |= fLow << 3;
break;
case ShiftType.ARITHMETIC_DOUBLE:
regCommon_[b] |= fHigh << 3;
regQ_ |= fLow << 3;
break;
}
break;
case ToType.SR_F_IN_B:
regCommon_[b] = f_ >> 1;
switch (shift)
{
case ShiftType.CYCLE:
regCommon_[b] |= fLow << 3;
break;
}
break;
case ToType.SL_F_IN_B_AND_SL_Q_IN_Q:
regQ_ = Helpers.Mask(regQ_ << 1);
regCommon_[b] = Helpers.Mask(f_ << 1);
switch (shift)
{
case ShiftType.CYCLE:
regCommon_[b] |= fHigh;
regQ_ |= qHigh;
break;
case ShiftType.CYCLE_DOUBLE:
regCommon_[b] |= qHigh;
regQ_ |= fHigh;
break;
case ShiftType.ARITHMETIC_DOUBLE:
regCommon_[b] |= qHigh;
break;
}
break;
case ToType.SL_F_IN_B:
regCommon_[b] = Helpers.Mask(f_ << 1);
switch (shift)
{
case ShiftType.CYCLE:
regCommon_[b] |= fHigh;
break;
}
break;
}
if (to == ToType.F_IN_B_AND_A_IN_Y)
{
y_ = regCommon_[a];
}
else
{
y_ = f_;
}
}
