Chests are treated as single chests always, so there is a little
potential for interaction getting through (blockinteract.visible).
Snow is just treated as before, data-based height adjustment (to be
added as a model, as Bukkit supports getting the level in a generic way,
same for water).
* Reinstate itchy blocks being processed at all (MCAccessBukkit).
* Refine block dump: add non-air blocks with no flags set to missing.
* Adjust/re-add/alter various flags.
* Initialize fully solid (in terms of shape + passable) blocks
explicitly with full bounds and solid flags.
* Use MaterialUtil#addBlocks and BridgeMaterial#getAllBlocks where
appropriate.
* MCAccessBukkit(Base): don't touch fully solid nor fully passable ones.
First batch:
* Initialize blocks somehow, so no errors nor missing blocks happen
during startup.
Possibly Missing:
* There might be references of removed/renamed material (blocks/items)
throughout the code.
* Some blocks may behave different now/then.
Missing:
* Block#getData may not reflect (all?) properties anymore.
* Block shape getting is missing. Block shapes are now (potentially)
more complex to process. Concept might be to keep a double array for the
rough bounds, and add an (optional +- null) array of arrays for sub
shapes, if present (IBlockCacheNode). So a first rough update is more
simple/compatible.
Create PlayerData instances if events allow proceeding:
* AsyncPlayerPreLogin.
* PlayerLogin (schedule for removal if denied).
Update world data:
* PlayerLogin
* (PlayerJoin, ...)
Update player name and log:
* PlayerLogin
* PlayerJoin
(+) PlayerData.updateCurrentWorld -> only do something if the WorldData
instance has changed.
Have a penalty list to collect input specific penalties from
ViolationData and apply after event handling.
Pass through the list to fight.critical.
Missing:
* Penalty factories and configuration. Penalty registry. Link with
actions.
* Pass through the penalty list to all fight checks.
* (Implement default penalty types.)
* ((Implement stored penalties.))
(+) Preparatory comments.
Something came in between back then, but now it's not efficient to do a
special case here. Instead, generic penalties will be implemented to
some extent.
Add block flags:
* F_VARIABLE_USE
* F_VARIABLE_REDSTONE
Add a test to ensure block flags are unique and not 0L.
(+) Use individual MiniListener instances.
(+) Track right click blocks (use block) and apply, aiming at trap door
issues.
Likely incomplete/broken somewhere.
Implement/extend/use/fix new data caches and factories.
(+) Fixes related to recent commits (e.g. log listener exceptions
properly, fight.wrongturn).
Missing:
* Debug logging (registry), consider a registry log file.
* Proper naming/tags for listeners.
* Consistency: ICheckData should probably be used with
removeData(CheckType)? Registration is arbitrary though.
* Consistency: clearData() vs clearData(CheckType.ALL) - should check
type related data be ICheckData only ?
* Data expiration stages and PlayerOfflineData - impact on memory...
* (...)
Further:
* WorldData inheritance issue: implement passing on changes to children.
(Current line of thought: rather extend IWorldDataManager to allow
change default+inherited only.)
* Shrink exposed API - uncertain: rather have a registration context
object or expose individual methods for factory registration and
grouping types?
* (...)
* Planned breakage: Project + package organization redone: move stuff
where it is best for having an API (components -> split to top level or
name it api, utilities ... parts belong into API, and the like...,
possibly split project further: commons, api(+-bukkit), core/checks,
plugin-bukkit).
asofold