public void FeedBackPulse()
{
foreach (Thing current in this.Map.listerThings.AllThings)
{
if (current.GetType() == typeof(Bookshelf))
{
Bookshelf bookshelf = current as Bookshelf;
if (bookshelf.MissingBooksList.Contains(def))
{
if (bookshelf.StoredBooks.Count < 3)
{
bookshelf.MissingBooksList.Remove(def);
bookshelf.StoredBooks.Add(def);
if (Spawned)
{
Destroy();
}
break;
}
}
}
}
if (Spawned)
{
Destroy();
}
}
public Toil TakeBookFromBookshelf(TargetIndex ind, Pawn reader, TargetIndex bookInd)
{
Toil takeBook = new Toil();
takeBook.initAction = delegate
{
bool flag = true;
Pawn actor = takeBook.actor;
Bookshelf bookshelf = (Bookshelf)actor.jobs.curJob.GetTarget(ind).Thing;
Thing thing = bookshelf.JobBook(reader);
if (thing == null)
{
actor.jobs.curDriver.EndJobWith(JobCondition.Incompletable);
}
else
{
ReadableBooks readableBooks = thing as ReadableBooks;
readableBooks.currentReader = reader;
actor.carryTracker.TryStartCarry(readableBooks);
actor.jobs.curJob.targetB = actor.carryTracker.CarriedThing;
}
if (flag)
{
if (this.pawn.Map.reservationManager.FirstReserverOf(bookshelf, bookshelf.Faction) == reader)
{
this.pawn.Map.reservationManager.Release(bookshelf, reader);
}
}
};
takeBook.defaultCompleteMode = ToilCompleteMode.Delay;
takeBook.defaultDuration = 20;
return(takeBook);
}
private void InterfaceDrop(ThingDef def, Bookshelf shelf)
{
Thing DroppedBook;
shelf.StoredBooks.Remove(def);
DroppedBook = ThingMaker.MakeThing(def);
GenPlace.TryPlaceThing(DroppedBook, shelf.Position, this.Shelf.Map, ThingPlaceMode.Near);
}
public Toil ReadEnd(Pawn reader, TargetIndex bookInd, TargetIndex BookShelfInd)
{
return(new Toil
{
initAction = delegate
{
Bookshelf bookshelf = (Bookshelf)reader.jobs.curJob.GetTarget(BookShelfInd).Thing;
ReadableBooks readableBooks = (ReadableBooks)reader.jobs.curJob.GetTarget(bookInd).Thing;
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
public static Toil PlaceBookInShelf(TargetIndex book, TargetIndex shelf, Pawn pawn)
{
ReadableBooks bookint = (ReadableBooks)pawn.jobs.curJob.GetTarget(book).Thing;
Bookshelf bookshelf = (Bookshelf)pawn.jobs.curJob.GetTarget(shelf).Thing;
Log.Message("Trying to place book");
Toil toil = new Toil();
toil.defaultCompleteMode = ToilCompleteMode.Instant;
toil.AddPreInitAction(delegate
{
bookint.Destroy(DestroyMode.Vanish);
bookshelf.AddBookToLibrary(bookint.Tdef);
});
return(toil);
}
// private ReadableBooks bookint;
// private Bookshelf bookshelf;
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnBurningImmobile(TargetIndex.B);
if (!base.TargetThingA.IsForbidden(this.pawn))
{
this.FailOnForbidden(TargetIndex.A);
}
yield return(Toils_Reserve.Reserve(TargetIndex.B, 2));
Toil toil = Toils_Reserve.Reserve(TargetIndex.A, 1);
toil.AddFinishAction(delegate
{
});
yield return(toil);
Toil toil2 = null;
toil2 = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
toil2.AddFinishAction(delegate
{
});
yield return(toil2);
this.pawn.CurJob.count = 1;
yield return(Toils_Haul.StartCarryThing(TargetIndex.A));
Toil toil3 = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
toil3.AddFinishAction(delegate
{
});
yield return(toil3);
Toil toil4 = Bookshelf.PlaceBookInShelf(TargetIndex.A, TargetIndex.B, this.pawn);
yield return(toil4);
yield break;
}
public Toil ReadingBook(Pawn reader, int durationMultiplier, TargetIndex Ind, TargetIndex bookInd)
{
Toil toil = new Toil();
List <string> text = new List <string>();
Bookshelf thing = null;
ReadableBooks thingBook = null;
int s = 0;
int i = 0;
int prog = 0;
int oldprog = 0;
float showTextFactor = 0;
bool tickOnce = false;
toil.tickAction = delegate
{
if (!tickOnce)
{
thing = (Bookshelf)reader.jobs.curJob.GetTarget(Ind).Thing;
thingBook = (ReadableBooks)reader.jobs.curJob.GetTarget(bookInd).Thing;
this.tempbook = thingBook;
if (thingBook.PrepareText().Count > 0)
{
text = thingBook.PrepareText();
}
showTextFactor = thingBook.Tdef.TextSpeedShowFactor;
if (soul != null)
{
foreach (KeyValuePair <ThingDef, int> current in soul.readablesManager.ReadableProgressEntry)
{
if (current.Key.defName == thingBook.def.defName)
{
prog = current.Value;
oldprog = prog;
s = current.Value / 150;
Log.Message("Old Progression Found: " + prog.ToString());
break;
}
}
}
thingBook.TexChange = true;
tickOnce = true;
}
if (thingBook.Tdef.SkillToLearn != null)
{
this.pawn.skills.Learn(thingBook.Tdef.SkillToLearn, thingBook.Tdef.SkillGainFactor * 1f);
}
prog += 1;
if (text.Count > 0)
{
if (i > showTextFactor * 150)
{
if (text.Count > s)
{
MoteMaker.ThrowText(reader.TrueCenter() + new Vector3(0f, 0f, 0.7f), thingBook.Map, text.ElementAt(s), Color.green);
reader.needs.joy.CurLevel += 0.03f;
s++;
thingBook.ReadCorruptionTick(this.pawn, thingBook);
i = 0;
}
}
i++;
}
reader.Drawer.rotator.FaceCell(thingBook.Position);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.FailOnDespawnedOrNull(TargetIndex.B);
toil.defaultDuration = durationMultiplier;
toil.AddFinishAction(delegate
{
if (soul != null)
{
Dictionary <ThingDef, int> entries = soul.readablesManager.ReadableProgressEntry;
if (entries.ContainsKey(thingBook.def))
{
entries[thingBook.def] = prog;
}
else
{
Log.Message("Adding Entry");
entries.Add(thingBook.def, prog);
}
}
thingBook.PostReadEffectSelection(prog, oldprog);
thingBook.TexChange = false;
this.tempshelf = thing;
this.tempbook = thingBook;
});
return(toil);
}
