Pocket Events Plugin [Basic][MZ]
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* License: Creative Commons 4.0 Attribution, Share Alike, Non-Commercial | |
* | |
* Copyright (c) 2021 Vladimir Skrypnikov (Pheonix KageDesu) | |
* <https://http://kdworkshop.net//> | |
* | |
*/ | |
/*: | |
* @plugindesc (v.1.3)[BASIC] Allow you spawn Events during game with placement select | |
* @author Pheonix KageDesu | |
* @target MZ | |
* @url https://kdworkshop.net/plugins/pocket-events/ | |
* | |
* | |
* @help | |
* | |
* This plugin allows player placing events from a specified 'template' map | |
* with placement selecting for them in the current map. | |
* This template map is designated with the "Templates Map" plugin setting. | |
* | |
* For create rules and setup placement events, see plugin parameter | |
* 'Placement Items' | |
* | |
* For place and removing events, use plugin commands. | |
* | |
* | |
* | |
* Since update 1.1. you can create draggable events. | |
* Player can dragging those events by mouse to another place on map. | |
* Set plugin parameter "Event Drag Drop?" to true for activate dragging. | |
* Setup dragging event rules in "Draggable Templates" plugin parameter. | |
* | |
* Add comment "draggable:X" (without quotes) on event page | |
* where X - number of dragging template from plugin parameters | |
* | |
* This is BASIC plugin version and have some restrictions: | |
* - Player can place only 5 pocket events on map at same time | |
* - Placed events not keeps when you change maps | |
* - Plugin usage allowed only in Non-Commercial project | |
* - Only 3 draggable events on same map | |
* - NOT have support of Alpha NET Z (multiplayer) plugin | |
* | |
* PRO version of plugin don't have this restrictions! | |
* | |
* Visit plugin web page for more information, also you can find Demo project. | |
* | |
* If you like my Plugins, want more and offten updates, | |
* please support me on Patreon! | |
* | |
* Patreon Page: | |
* https://www.patreon.com/KageDesu | |
* YouTube Channel: | |
* https://www.youtube.com/channel/UCA3R61ojF5vp5tGwJ1YqdgQ? | |
* | |
* You can use this plugin in your game thanks to all my Patrons! | |
* | |
* License: Creative Commons 4.0 Attribution, Share Alike, Non-Commercial | |
* | |
* | |
* @param TemplatesMap | |
* @text Templates Map | |
* @type number | |
* @min 1 | |
* @default 1 | |
* @desc Map ID with Placement Events templates | |
* | |
* @param GlobalExceptRegions | |
* @text Forbidden Regions | |
* @type number[] | |
* @min 1 | |
* @max 255 | |
* @desc Region ID's where placement items cannot be placed | |
* @default [] | |
* | |
* @param PlacementsList | |
* @text Placement Items | |
* @type struct<PlacementItem>[] | |
* @desc Placement Items List | |
* @default [] | |
* | |
* @param AllowArrowMove | |
* @text Keyboard Moving? | |
* @type boolean | |
* @default false | |
* @desc Allow moving placement item when place by arrow keys? (if false - only by mouse) | |
* | |
* @param AllowEventDragging | |
* @text Event Drag Drop? | |
* @type boolean | |
* @default true | |
* @desc Allow player dragging draggable (must have special comment) events? | |
* | |
* @param DraggableList | |
* @text Draggable Templates | |
* @type struct<DraggableItem>[] | |
* @desc Draggable Events Settings Templates List | |
* @default [] | |
* @command PlacePocketEvent | |
* @text Place Pocket Event | |
* @desc Placing pocket event on map with placement select | |
* | |
* @arg placementItemId | |
* @text Placement Item | |
* @desc Placement Item Index from Placement Items plugin parameter | |
* @type number | |
* @min 1 | |
* @default 1 | |
* | |
* @arg gameItemId | |
* @text Consume Item | |
* @desc Item that's will be deleting from inventory when item is placed [optional] | |
* @type item | |
* @default 0 | |
* | |
* @command RemovePocketEvent | |
* @text PickUp By Place Item | |
* @desc PickUp (removing) pocket event from map | |
* | |
* @arg placementItemId | |
* @text Placement Item | |
* @desc Placement Item Index from Placement Items plugin parameter | |
* @type number | |
* @min 1 | |
* @default 1 | |
* | |
* @arg gameItemId | |
* @text Gain Item | |
* @desc Item that's will be added to inventory when item is removed from map [optional] | |
* @type item | |
* @default 0 | |
* | |
* @command RemovePocketEvent2 | |
* @text PickUp By Event | |
* @desc PickUp (removing) current pocket event from map | |
* | |
* @arg gameItemId | |
* @text Gain Item | |
* @desc Item that's will be added to inventory when item is removed from map [optional] | |
* @type item | |
* @default 0 | |
*/ | |
/*~struct~PlacementItem: | |
@param eventId | |
@text Event ID | |
@type number | |
@default 1 | |
@min 1 | |
@desc Event ID on Placements Templates Map | |
@param animationId | |
@text Place Animation | |
@type animation | |
@default 0 | |
@desc Animation that will be playing after item placed | |
@param gridVisiblity | |
@text Grid | |
@type boolean | |
@default true | |
@desc Show map grid when this item placing? | |
@param sSwitch | |
@text Self Switch | |
@type combo | |
@option None | |
@option A | |
@option B | |
@option C | |
@option D | |
@default None | |
@desc Select which Self Switch will be turned ON when item been placed | |
@param exceptRegions | |
@text Forbidden Regions | |
@type number[] | |
@min 1 | |
@max 255 | |
@desc Region ID's where this item cannot be placed | |
@default [] | |
@param onlyRegions | |
@text Allowed Only Regions | |
@type number[] | |
@min 1 | |
@max 255 | |
@desc Only Region ID's where this item can be placed | |
@default [] | |
@param ceSpawnGood | |
@text On Placed CE | |
@type common_event | |
@default 0 | |
@desc Common event called after item been placed | |
@param canSpawnOverEvents | |
@text Place On Events? | |
@type boolean | |
@default false | |
@desc Can be this item placed on (above) other map events? | |
@param ceSpawnCancel | |
@text On Cancel CE | |
@type common_event | |
@default 0 | |
@desc Common event called if player not placed item, just cancel placement (ESC or right mouse click) | |
@param isShouldPauseMap | |
@text Pause Game? | |
@type boolean | |
@default false | |
@desc Pause game map when player placing this item? | |
@param maxDistance | |
@text Distance | |
@type number | |
@default 0 | |
@min 0 | |
@desc Maximum allowed distance (from player) to place this item. 0 - unlimited | |
@param allowMargin | |
@text Allow Y Offset? | |
@type boolean | |
@default false | |
@desc If true, you can change object height offset by mouse scroll (when placing) | |
@param marginStep | |
@parent allowMargin | |
@text Step | |
@type number | |
@default 1 | |
@min 1 | |
@desc Y coordinate changing step (in px) | |
@param marginMin | |
@parent allowMargin | |
@text Min Offset | |
@type number | |
@default -20 | |
@min -100 | |
@max -1 | |
@desc Lower allowed height offset value | |
@param marginMax | |
@parent allowMargin | |
@text Max Offset | |
@type number | |
@default 20 | |
@min 1 | |
@max 100 | |
@desc Upper allowed height offset value | |
*/ | |
/*~struct~DraggableItem: | |
@param gridVisiblity | |
@text Grid | |
@type boolean | |
@default true | |
@desc Show map grid when this event dragging? | |
@param exceptRegions | |
@text Forbidden Regions | |
@type number[] | |
@min 1 | |
@max 255 | |
@desc Region ID's where this event cannot be placed after dragging | |
@default [] | |
@param ceSpawnGood | |
@text On Placed CE | |
@type common_event | |
@default 0 | |
@desc Common event called after event been placed (after dragging) | |
@param canSpawnOverEvents | |
@text Place On Events? | |
@type boolean | |
@default false | |
@desc Can be this event placed on (above) other map events? | |
@param isShouldPauseMap | |
@text Pause Game? | |
@type boolean | |
@default false | |
@desc Pause game map when player dragging this event? | |
@param image | |
@text Drag Image | |
@type struct<DraggableItemImage> | |
@default | |
@desc Change event graphic to this image when event is dragging, optional | |
*/ | |
/*~struct~DraggableItemImage: | |
@param characterName | |
@text Graphic | |
@type file | |
@dir img/characters/ | |
@require 1 | |
@default | |
@desc Character graphic file | |
@param characterIndex | |
@text Index | |
@type number | |
@min 0 | |
@desc Charcter Index on character graphics | |
@default 0 | |
*/ | |
var Imported = Imported || {}; | |
Imported.PKD_EasyPlacement = true; | |
Imported.PKD_PocketEvents = true; | |
var PKD_EasyPlacement = {}; | |
PKD_EasyPlacement.LIBS = {}; | |
PKD_EasyPlacement.register = function (library) { | |
this.LIBS[library.name] = library; | |
}; | |
var PKD_PocketEvents = PKD_EasyPlacement; | |
var KDCoreMini = {}; | |
window.KDCoreMini = KDCoreMini; | |
KDCoreMini.Utils = {}; | |
//TODO: Π KDCore | |
KDCoreMini.makeid = function(length) { | |
var result = ''; | |
var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; | |
var charactersLength = characters.length; | |
for (var i = 0; i < length; i++) { | |
result += characters.charAt(Math.floor(Math.random() * | |
charactersLength)); | |
} | |
return result; | |
}; | |
(function () { | |
Array.prototype.delete = function () { | |
var L, a, ax, what; | |
what = void 0; | |
a = arguments; | |
L = a.length; | |
ax = void 0; | |
while (L && this.length) { | |
what = a[--L]; | |
while ((ax = this.indexOf(what)) !== -1) { | |
this.splice(ax, 1); | |
} | |
} | |
return this; | |
}; | |
KDCoreMini.TimedUpdate = class TimedUpdate { | |
constructor(interval, method1) { | |
this.interval = interval; | |
this.method = method1; | |
this._timer = 0; | |
this._once = false; | |
} | |
update() { | |
if (this.interval == null) { | |
return; | |
} | |
this._timer++; | |
if (this._timer >= this.interval) { | |
if (this.method != null) { | |
this.method(); | |
} | |
this._timer = 0; | |
if (this._once === true) { | |
return this.stop(); | |
} | |
} | |
} | |
once() { | |
return this._once = true; | |
} | |
onUpdate(method1) { | |
this.method = method1; | |
} | |
stop() { | |
return this.interval = null; | |
} | |
isAlive() { | |
return this.interval != null; | |
} | |
}; | |
KDCoreMini.Utils.getEventCommentValue = function (commentCode, list) { | |
var comment, e, item; | |
try { | |
if (list && list.length > 1) { | |
i = 0; | |
while (i < list.length) { | |
item = list[i++]; | |
if (!item) { | |
continue; | |
} | |
if (item.code === 108) { | |
comment = item.parameters[0]; | |
if (comment.contains(commentCode)) { | |
return comment; | |
} | |
} | |
} | |
} | |
} catch (error1) { | |
e = error1; | |
console.warn(e); | |
} | |
return null; | |
}; | |
KDCoreMini.isMZ = function () { | |
return Utils.RPGMAKER_NAME.contains("MZ"); | |
}; | |
})(); | |
(function(){ | |
PKD_EasyPlacement.pluginName = "PKD_PocketEvents"; | |
PKD_EasyPlacement.LoadPluginSettings = () => { | |
const params = PluginManager.parameters(PKD_EasyPlacement.pluginName); | |
//console.info(params); | |
PKD_EasyPlacement.ITEMS_MAP = parseInt(params.TemplatesMap) || 0; | |
PKD_EasyPlacement.PARAMS = {}; | |
PKD_EasyPlacement.PARAMS.BAD_REGIONS = ParsePluginRegionArray(params.GlobalExceptRegions); | |
PKD_EasyPlacement.PARAMS.ITEMS = ParsePluginItemsList(params.PlacementsList); | |
PKD_EasyPlacement.PARAMS.ALLOW_ARROW_MOVE = JsonEx.parse(params.AllowArrowMove || "false"); | |
PKD_EasyPlacement.PARAMS.ALLOW_DRAG = JsonEx.parse(params.AllowEventDragging || "true"); | |
PKD_EasyPlacement.PARAMS.DRAG_ITEMS = ParsePluginDraggableList(params.DraggableList); | |
//console.info(PKD_EasyPlacement.PARAMS); | |
if(KDCoreMini.isMZ()) | |
RegisterPluginCommnads(); | |
ConfigurateClasses(); | |
}; | |
ParsePluginRegionArray = (arrayList) => { | |
let list = JsonEx.parse(arrayList); | |
list = list.map((e) => parseInt(e)); | |
return list; | |
}; | |
ParsePluginItemsList = (arrayList) => { | |
let lines = JsonEx.parse(arrayList); | |
let parsed = lines.map((l) => JsonEx.parse(l)); | |
parsed.forEach(element => { | |
element.gridVisiblity = JsonEx.parse(element.gridVisiblity); | |
element.animationId = parseInt(element.animationId); | |
element.eventId = parseInt(element.eventId); | |
element.exceptRegions = ParsePluginRegionArray(element.exceptRegions); | |
element.onlyRegions = ParsePluginRegionArray(element.onlyRegions); | |
// * ΠΡΠΎΠ²Π΅ΡΠΊΠ°, ΡΠ°ΠΊ ΠΊΠ°ΠΊ ΠΏΠ°ΡΠ°ΠΌΠ΅ΡΡΡ Π±ΡΠ»ΠΈ Π΄ΠΎΠ±Π°Π²Π»Π΅Π½Ρ Π² ΠΎΠ±Π½ΠΎΠ²Π»Π΅Π½ΠΈΡΡ | |
if(element.ceSpawnGood) { | |
element.ceSpawnGood = parseInt(element.ceSpawnGood); | |
} else { | |
element.ceSpawnGood = 0; | |
} | |
if(element.ceSpawnCancel) { | |
element.ceSpawnCancel = parseInt(element.ceSpawnCancel); | |
} else { | |
element.ceSpawnCancel = 0; | |
} | |
if(element.canSpawnOverEvents) { | |
element.canSpawnOverEvents = JsonEx.parse(element.canSpawnOverEvents); | |
} else { | |
element.canSpawnOverEvents = false; | |
} | |
if(element.isShouldPauseMap) { | |
element.isShouldPauseMap = JsonEx.parse(element.isShouldPauseMap); | |
} else { | |
element.isShouldPauseMap = false; | |
} | |
if(element.maxDistance) { | |
element.maxDistance = parseInt(element.maxDistance); | |
} else { | |
element.maxDistance = 0; | |
} | |
// * MARGINS | |
if(element.allowMargin) { | |
element.allowMargin = JsonEx.parse(element.allowMargin); | |
} else { | |
element.allowMargin = false; | |
} | |
if(element.marginStep) { | |
element.marginStep = parseInt(element.marginStep); | |
} else { | |
element.marginStep = 1; | |
} | |
if(element.marginMix) { | |
element.marginMix = parseInt(element.marginMix); | |
} else { | |
element.marginMin = -20; | |
} | |
if(element.marginMax) { | |
element.marginMax = parseInt(element.marginMax); | |
} else { | |
element.marginMax = 20; | |
} | |
}); | |
parsed = [null].concat(parsed); | |
return parsed; | |
}; | |
ParsePluginDraggableList = (arrayList) => { | |
if(!arrayList) return []; | |
let lines = JsonEx.parse(arrayList); | |
let parsed = lines.map((l) => JsonEx.parse(l)); | |
parsed.forEach(element => { | |
element.gridVisiblity = JsonEx.parse(element.gridVisiblity); | |
element.exceptRegions = ParsePluginRegionArray(element.exceptRegions); | |
element.ceSpawnGood = parseInt(element.ceSpawnGood); | |
element.canSpawnOverEvents = JsonEx.parse(element.canSpawnOverEvents); | |
element.isShouldPauseMap = JsonEx.parse(element.isShouldPauseMap); | |
if(element.image) { | |
element.image = JsonEx.parse(element.image); | |
} else { | |
element.image = null; | |
} | |
}); | |
parsed = [null].concat(parsed); | |
return parsed; | |
}; | |
RegisterPluginCommnads = () => { | |
PluginManager.registerCommand(PKD_EasyPlacement.pluginName, 'PlacePocketEvent', args => { | |
try { | |
let pItemId = parseInt(args.placementItemId); | |
let gItemId = parseInt(args.gameItemId); | |
if(pItemId >= 0) | |
PKD_EPManager.Start(pItemId, gItemId); | |
} catch (e) { | |
console.warn(e); | |
} | |
}); | |
PluginManager.registerCommand(PKD_EasyPlacement.pluginName, 'RemovePocketEvent', args => { | |
try { | |
let pItemId = parseInt(args.placementItemId); | |
let gItemId = parseInt(args.gameItemId); | |
if (pItemId >= 0) | |
PKD_EPManager.PickUpPlacedItem(pItemId, gItemId); | |
} catch (e) { | |
console.warn(e); | |
} | |
}); | |
PluginManager.registerCommand(PKD_EasyPlacement.pluginName, 'RemovePocketEvent2', args => { | |
try { | |
let gItemId = parseInt(args.gameItemId); | |
let pEventId = $gameMap._interpreter.eventId(); | |
if (pEventId >= 0) | |
PKD_EPManager.PickUpPlacedItemByEvent(pEventId, gItemId); | |
} catch (e) { | |
console.warn(e); | |
} | |
}); | |
}; | |
ConfigurateClasses = () => { | |
if(PKD_EasyPlacement.PARAMS.ALLOW_DRAG == false) { | |
Scene_Map.prototype.pProcessMapEventDragging = () => {}; | |
} | |
// * Π‘ΠΎΠ²ΠΌΠ΅ΡΡΠΈΠΌΠΎΡΡΡ Ρ MapInventory (ΠΈΡΠΏΡΠ°Π²Π»ΡΠ΅Ρ Π½Π΅ΠΊΠΎΡΠΎΡΡΠ΅ ΠΊΠΎΡΡΡΠΊΠΈ) | |
if(Imported.PKD_MapInventory == true) { | |
PKD_EasyPlacement.applyMIPatch(); | |
} | |
// * Π‘ΠΎΠ²ΠΌΠ΅ΡΡΠΈΠΌΠΎΡΡΡ Ρ Alpha NET Z | |
if(Imported.Alpha_NETZ == true) { | |
PKD_EasyPlacement.applyNETZPatch(); | |
} | |
}; | |
})(); | |
// Generated by CoffeeScript 2.5.1 | |
// * MAIN | |
Array.prototype.last = function() { | |
return this[this.length - 1]; | |
}; | |
TouchInput.mapPoint = function() { | |
var x, y; | |
x = $gameMap.canvasToMapX(TouchInput.x); | |
y = $gameMap.canvasToMapY(TouchInput.y); | |
return {x, y}; | |
}; | |
TouchInput.mapScreenPoint = function() { | |
var t, th, tw, x, y; | |
({x, y} = TouchInput.mapPoint()); | |
t = $gameMap.adjustX(x); | |
tw = $gameMap.tileWidth(); | |
x = Math.round(t * tw + tw / 2); | |
t = $gameMap.adjustY(y); | |
th = $gameMap.tileHeight(); | |
y = Math.round(t * th + th); | |
return {x, y}; | |
}; | |
// Generated by CoffeeScript 2.5.1 | |
var PKD_EPManager; | |
PKD_EPManager = function() {}; | |
(function() { | |
var _; | |
_ = PKD_EPManager; | |
_.Scene = function() { | |
return SceneManager._scene; | |
}; | |
_.OnMapLoaded = function() { | |
this.isActive = false; | |
this.SetGridVisibility(false); | |
if (this.isShouldLoadEvents()) { | |
this.CreateEPEventsOnMap(); | |
$gameSystem.pRestoreDraggableEventsPositions(); | |
this.RestoreMargins(); | |
return this.isNextMapLoaded = false; | |
} | |
}; | |
_.OnNextMapLoaded = function() { | |
return this.isNextMapLoaded = true; | |
}; | |
_.isShouldLoadEvents = function() { | |
return this.isNextMapLoaded === true; | |
}; | |
_.IsGridVisible = function() { | |
return this.isGridVisible; | |
}; | |
_.IsActive = function() { | |
return this.isActive === true; | |
}; | |
_.IsPointIsGood = function() { | |
if (this.IsActive()) { | |
return this.IsPointIsGoodForPlacement(); | |
} else if (this.IsEventDragStart()) { | |
return this.IsPointIsGoodForDrag(); | |
} else { | |
return true; | |
} | |
}; | |
_.IsPointIsGoodForPlacement = function() { | |
var x, y; | |
// * ΠΠΎΡΠΎΠΌΡ ΡΡΠΎ Π΄ΠΎΠ±Π°Π²ΠΈΠ» Π΄Π²ΠΈΠΆΠ΅Π½ΠΈΠ΅ ΡΡΡΠ΅Π»ΠΊΠ°ΠΌΠΈ | |
if ($gameTemp._epSpawned != null) { | |
({x, y} = $gameTemp._epSpawned); | |
} else { | |
({x, y} = TouchInput.mapPoint()); | |
} | |
// * Π’ΠΎΠ»ΡΠΊΠΎ Π΅ΡΠ»ΠΈ Π½Π΅Π»ΡΠ·Ρ ΡΠΏΠ°Π²Π½ΠΈΡΡ Π½Π° Π΄ΡΡΠ³ΠΈΠ΅ ΡΠΎΠ±ΡΡΠΈΡ (ΠΏΠΎ ΡΠΌΠΎΠ»ΡΠ°Π½ΠΈΡ) | |
if (!$gameTemp._epSpawnModeOverEvents) { | |
// * > 1 because self under mouse | |
if ($gameMap.eventsXy(x, y).length > 1) { | |
return false; | |
} | |
} | |
if ($gamePlayer.pos(x, y)) { | |
return false; | |
} | |
if (Game_CharacterBase.prototype.isCollidedWithVehicles(x, y)) { | |
return false; | |
} | |
if (!this.CheckRegions(x, y)) { | |
return false; | |
} | |
return this.CheckDistance(x, y); | |
}; | |
_.CheckRegions = function(x, y) { | |
var item, region, regionSet; | |
regionSet = PKD_EasyPlacement.PARAMS.BAD_REGIONS; | |
region = $gameMap.regionId(x, y); | |
if (regionSet.contains(region)) { | |
return false; | |
} | |
item = this.CurrentPlacementItemData(); | |
if (item == null) { | |
return true; | |
} | |
if (item.onlyRegions.length > 0) { | |
if (!item.onlyRegions.contains(region)) { | |
return false; | |
} | |
} else if (item.exceptRegions.length > 0) { | |
if (item.exceptRegions.contains(region)) { | |
return false; | |
} | |
} | |
return true; | |
}; | |
_.CheckDistance = function(x, y) { | |
var allowedDist, dist, item; | |
item = this.CurrentPlacementItemData(); | |
if (item == null) { | |
return true; | |
} | |
allowedDist = item.maxDistance; | |
if (allowedDist > 0) { | |
dist = $gameMap.distance($gamePlayer.x, $gamePlayer.y, x, y); | |
return dist <= allowedDist; | |
} else { | |
return true; | |
} | |
}; | |
_.SetGridVisibility = function(isGridVisible) { | |
this.isGridVisible = isGridVisible; | |
}; | |
_.ItemData = function(pItemIndex) { | |
return PKD_EasyPlacement.PARAMS.ITEMS[pItemIndex]; | |
}; | |
_.CurrentPlacementItemData = function() { | |
var itemData; | |
if (!$gameTemp._epPlacementItemId) { | |
return null; | |
} | |
itemData = this.ItemData($gameTemp._epPlacementItemId); | |
return itemData; | |
}; | |
//?VERSION | |
_.Start = function(pItemIndex, gItemId = 0) {}; | |
// * Π‘ΠΎΡ ΡΠ°Π½ΡΠ΅ΠΌ ΡΠ΅ΠΊΡΡΠΈΠΉ ΠΏΡΠ΅Π΄ΠΌΠ΅Ρ Π΄Π»Ρ Π΄Π°Π»ΡΠ½Π΅ΠΉΡΠ΅ΠΉ ΡΠ°Π±ΠΎΡΡ Ρ Π½ΠΈΠΌ | |
_.RegisterPlacementItem = function(pItemIndex, gItemId) { | |
$gameTemp._epPlacementPartyItemId = gItemId; | |
$gameTemp._epPlacementItemId = pItemIndex; | |
}; | |
_.Stop = function() { | |
//"STOP".p() | |
this.Scene().pEndEPMode(); | |
this.SetGridVisibility(false); | |
this.isActive = false; | |
this.ClearRegisteredPlacementItem(); | |
}; | |
_.ClearRegisteredPlacementItem = function() { | |
$gameTemp._epPlacementPartyItemId = null; | |
$gameTemp._epPlacementItemId = null; | |
}; | |
_.PlaceItemOn = function(x, y) { | |
var commonEventId, dbItem, evId, itemId, marginY, uniqueId; | |
evId = $gameTemp._epSpawned.eventId(); | |
itemId = $gameTemp._epPlacementItemId; | |
dbItem = $gameSystem.pRegisterEPItem($gameMap.mapId(), itemId, x, y, evId); | |
this.ActivatePlacedItem($gameMap.mapId(), itemId, evId); | |
this.ChangePlacementItem(-1); | |
this.CallPlacementAnimation($gameTemp._epSpawned, itemId); | |
if (PKD_PocketEvents.IsNetworkGame()) { | |
uniqueId = PKD_EPManager.GenerateUniqueId(); | |
dbItem.push(uniqueId); | |
marginY = $gameTemp._epSpawned.epMY; | |
PKD_EPManager.SendItemPlacedToServer(x, y, uniqueId, marginY); | |
} | |
commonEventId = this.ItemData(itemId).ceSpawnGood; | |
if (commonEventId > 0) { | |
$gameTemp.reserveCommonEvent(commonEventId); | |
} | |
}; | |
_.CallPlacementAnimation = function(event, itemId) { | |
var animationId; | |
animationId = this.ItemData(itemId).animationId; | |
if (animationId > 0) { | |
$gameTemp.requestAnimation([event], animationId); | |
} | |
}; | |
_.CallCancelCommonEvent = function() { | |
var commonEventId, itemId; | |
if ($gameTemp._epPlacementItemId == null) { | |
return; | |
} | |
itemId = $gameTemp._epPlacementItemId; | |
commonEventId = this.ItemData(itemId).ceSpawnCancel; | |
if (commonEventId > 0) { | |
$gameTemp.reserveCommonEvent(commonEventId); | |
} | |
}; | |
_.ChangePlacementItem = function(count) { | |
var itemId; | |
itemId = $gameTemp._epPlacementPartyItemId; | |
if (itemId == null) { | |
return; | |
} | |
if ($dataItems[itemId] == null) { | |
return; | |
} | |
return $gameParty.gainItem($dataItems[itemId], count); | |
}; | |
_.ActivatePlacedItem = function(mapId, itemId, eventId) { | |
var key, sSwitch; | |
sSwitch = this.ItemData(itemId).sSwitch; | |
if (sSwitch === "None" || sSwitch === "") { | |
return; | |
} | |
key = [mapId, eventId, sSwitch]; | |
$gameSelfSwitches.setValue(key, true); | |
return $gameMap.requestRefresh(); | |
}; | |
_.ClearSelfSwitches = function(mapId, eventId) { | |
var j, key, len, ref, s; | |
ref = ['A', 'B', 'C', 'D']; | |
for (j = 0, len = ref.length; j < len; j++) { | |
s = ref[j]; | |
key = [mapId, eventId, s]; | |
$gameSelfSwitches.setValue(key, false); | |
} | |
if (mapId === $gameMap.mapId()) { | |
$gameMap.requestRefresh(); | |
} | |
}; | |
// * Π£Π΄Π°Π»ΡΠ΅Ρ ΠΏΠΎ ΡΠΎΠ±ΡΡΠΈΡ | |
_.PickUpPlacedItemByEvent = function(eventId, gItemId = 0) { | |
var ev, uniqueId; | |
ev = $gameMap.event(eventId); | |
if (ev == null) { | |
return; | |
} | |
if (ev.pGetEPDynamicObjId() < 0) { | |
return; | |
} | |
$gameSystem.pRemoveEPItem($gameMap.mapId(), eventId); | |
this.Scene().pUnSpawnEPEvent(eventId); | |
PKD_EPManager.ClearSelfSwitches($gameMap.mapId(), eventId); | |
if (PKD_PocketEvents.IsNetworkGame()) { | |
uniqueId = PKD_EPManager.GetUniqueIdBySpawnedEvent(eventId); | |
PKD_EPManager.SendItemRemovedToServer(eventId, uniqueId); | |
} | |
if (gItemId <= 0) { | |
return; | |
} | |
$gameTemp._epPlacementPartyItemId = gItemId; | |
this.ChangePlacementItem(1); | |
$gameTemp._epPlacementPartyItemId = null; | |
}; | |
// * Π£Π΄Π°Π»ΡΠ΅Ρ ΠΏΠΎ ΠΏΡΠ΅Π΄ΠΌΠ΅ΡΡ, ΡΠΎΠ±ΡΡΠΈΠ΅ ΡΠ°ΠΌ Π½Π°Ρ ΠΎΠ΄ΠΈΡ | |
_.PickUpPlacedItem = function(pItemIndex, gItemId) { | |
var db, item; | |
db = $gameSystem.pGetEPDB()[$gameMap.mapId()]; | |
if (db == null) { | |
return; | |
} | |
item = db.find(function(i) { | |
return i[0] === pItemIndex; | |
}); | |
if (item == null) { | |
return; | |
} | |
return this.PickUpPlacedItemByEvent(item[3], gItemId); | |
}; | |
//?VERSION | |
_.CreateEPEventsOnMap = function() {}; | |
(function() { // * EVENT DRAGGING SYSTEM | |
// * ================================================================== | |
_.IsEventDragStart = function() { | |
return $gameTemp.pLastDraggableEvent != null; | |
}; | |
_.OnEventDragEnd = function() { | |
if ($gameTemp.pLastDraggableEvent == null) { | |
return; | |
} | |
this.Scene().pOnDragEnd(); | |
$gameTemp.pLastDraggableEvent = null; | |
}; | |
_.GetDraggableEventUnderMouse = function() { | |
var event; | |
event = null; | |
// * ΠΠΎΠΈΡΠΊ ΠΏΠΎ ΡΠΎΠ±ΡΡΠΈΡ | |
event = $gameMap.pGetDraggableEventInTouchPoint(); | |
// * ΠΡΠ»ΠΈ Π½Π΅ Π½Π°ΠΉΠ΄Π΅Π½ΠΎ, ΠΏΠΎΠΈΡΠΊ ΠΏΠΎ ΡΠΏΡΠ°ΠΉΡΡ ΡΠΎΠ±ΡΡΠΈΡ | |
if (event == null) { | |
event = this.Scene().pGetDraggableEventInTouchPoint(); | |
} | |
return event; | |
}; | |
_.StartEventDrag = function() { | |
$gameTemp.pPauseMap = false; | |
$gameTemp.pLastDraggableEvent = this.GetDraggableEventUnderMouse(); | |
if ($gameTemp.pLastDraggableEvent == null) { | |
return; | |
} | |
this.Scene().pOnDragStart(); | |
}; | |
_.OnEventDragProcess = function() {}; // * EMPTY | |
_.IsPointIsGoodForDrag = function() { | |
var x, y; | |
({x, y} = TouchInput.mapPoint()); | |
// * Π’ΠΎΠ»ΡΠΊΠΎ Π΅ΡΠ»ΠΈ Π½Π΅Π»ΡΠ·Ρ ΡΠΏΠ°Π²Π½ΠΈΡΡ Π½Π° Π΄ΡΡΠ³ΠΈΠ΅ ΡΠΎΠ±ΡΡΠΈΡ (ΠΏΠΎ ΡΠΌΠΎΠ»ΡΠ°Π½ΠΈΡ) | |
if (!$gameTemp._epSpawnModeOverEvents) { | |
// * ΠΠΎΠΆΠ½ΠΎ Π²Π΅ΡΠ½ΡΡΡ Π½Π° ΡΠ²ΠΎΡ ΠΌΠ΅ΡΡΠΎ, ΠΏΠΎΡΡΠΎΠΌΡ Π΄ΠΎΠΏ. ΠΏΡΠΎΠ²Π΅ΡΠΊΠ° Π½Π° ΡΠ²ΠΎΡ ΠΏΠΎΠ·ΠΈΡΠΈΡ | |
if ($gameMap.eventsXy(x, y).length > 0 && !$gameTemp.pLastDraggableEvent.pos(x, y)) { | |
return false; | |
} | |
} | |
if ($gamePlayer.pos(x, y)) { | |
return false; | |
} | |
if (Game_CharacterBase.prototype.isCollidedWithVehicles(x, y)) { | |
return false; | |
} | |
return $gameTemp.pLastDraggableEvent.pOnDragCheckRegion(x, y); | |
}; | |
//?VERSION | |
return _.ExtractDraggableEventComment = function(list) {}; | |
})(); | |
})(); | |
// Generated by CoffeeScript 2.5.1 | |
//$[ENCODE] | |
//$[ENCODE] | |
PKD_EPManager.CreateEPEventsOnMap = function() { | |
var db, mapId; | |
db = $gameSystem.pGetEPDB(); | |
mapId = $gameMap.mapId(); | |
if (!db[mapId]) { | |
return; | |
} | |
return db[mapId] = []; | |
}; | |
PKD_EPManager.Start = function(pItemIndex, gItemId = 0) { | |
var db, item, mapId; | |
if (pItemIndex == null) { | |
return; | |
} | |
if (pItemIndex < 0) { | |
return; | |
} | |
item = this.ItemData(pItemIndex); | |
if (item == null) { | |
return; | |
} | |
if (item.eventId <= 0) { | |
return; | |
} | |
db = $gameSystem.pGetEPDB(); | |
mapId = $gameMap.mapId(); | |
if ((db[mapId] != null) && db[mapId].length >= 5) { | |
window.alert("Placement more than 5 items allowed in [PRO] version of the plugin"); | |
return; | |
} | |
this.RegisterPlacementItem(pItemIndex, gItemId); | |
$gameTemp._epSpawnModeOverEvents = item.canSpawnOverEvents === true; | |
// * Π ΡΠ΅ΡΠ΅Π²ΠΎΠΉ ΠΈΠ³ΡΠ΅ ΠΏΠ°ΡΠ·Π° ΠΈΠ³ΡΡ Π½Π΅Π΄ΠΎΡΡΡΠΏΠ½Π° | |
$gameTemp.pPauseMap = item.isShouldPauseMap === true && !PKD_PocketEvents.IsNetworkGame(); | |
this.Scene().pActivateEPMode(item.eventId); | |
this.SetGridVisibility(item.gridVisiblity); | |
this.isActive = true; | |
}; | |
PKD_EPManager.ExtractDraggableEventComment = function(list) { | |
var comment, data, e; | |
if (this._draggableCount == null) { | |
this._draggableCount = 0; | |
} | |
if (this._draggableCount >= 3) { | |
//window.alert("Set draggable more than 3 events allowed in [PRO] version of the plugin") | |
console.warn("Set draggable more than 3 events allowed in [PRO] version of the plugin"); | |
return null; | |
} | |
if (list == null) { | |
return null; | |
} | |
try { | |
comment = KDCoreMini.Utils.getEventCommentValue('draggable', list); | |
if (comment != null) { | |
data = parseInt(comment.split(':')[1]); | |
if ((data != null) && data > 0) { | |
this._draggableCount++; | |
} | |
return data; | |
} | |
} catch (error) { | |
e = error; | |
console.warn(e); | |
return null; | |
} | |
return null; | |
}; | |
PKD_EPManager.RestoreMargins = function() {}; // * EMPTY | |
function Game_EPEvent() { | |
this.initialize.apply(this, arguments); | |
} | |
Game_EPEvent.prototype = Object.create(Game_Event.prototype); | |
Game_EPEvent.prototype.constructor = Game_EPEvent; | |
Game_EPEvent.prototype.initialize = function (templateEventId, eventId, epItemId) { | |
this._templateEventId = templateEventId; | |
this._epItemId = epItemId; | |
Game_Event.prototype.initialize.call(this, $gameMap.mapId(), eventId); | |
DataManager.extractMetadata(this.event()); | |
this.setPosition(-1, -1); | |
}; | |
Game_EPEvent.prototype.event = function () { | |
return $dataEPEventsMap.events[this._templateEventId]; | |
}; | |
Game_EPEvent.prototype.pGetEPDynamicObjId = function () { | |
return 1; // * JUST FOR CONDITIONS | |
}; | |
// Generated by CoffeeScript 2.5.1 | |
(function() { | |
var Sprite_GridCell; | |
Sprite_GridCell = class Sprite_GridCell extends Sprite { | |
constructor() { | |
super(new Bitmap($gameMap.tileWidth(), $gameMap.tileHeight())); | |
this.anchor.x = 0.5; | |
this.anchor.y = 1; | |
this.z = 1; | |
this.maxOpacity = 80; | |
this.minOpacity = 40; | |
this.opacity = this.maxOpacity; | |
this.setNormalColor(); | |
this.updateOpacityChange = this.updateOpacityDown; | |
this.colorChangeThread = new KDCoreMini.TimedUpdate(2, this._colorChange.bind(this)); | |
this._colorChange(); | |
} | |
setNormalColor() { | |
return this.bitmap.fillAll('rgba(255, 255, 255, 1)'); | |
} | |
setForbiddenColor() { | |
return this.bitmap.fillAll('rgba(255, 0, 0, 1)'); | |
} | |
update() { | |
super.update(); | |
if (this.visible === false) { | |
return; | |
} | |
this.updateOpacityChange(); | |
return this.colorChangeThread.update(); | |
} | |
_colorChange() { | |
if (!this.visible) { | |
return; | |
} | |
if (PKD_EPManager.IsPointIsGood()) { | |
return this.setNormalColor(); | |
} else { | |
return this.setForbiddenColor(); | |
} | |
} | |
updateOpacityChange() {} // * EMPTPY | |
updateOpacityDown() { | |
this.opacity -= 3; | |
if (this.opacity <= this.minOpacity) { | |
return this.updateOpacityChange = this.updateOpacityUp; | |
} | |
} | |
updateOpacityUp() { | |
this.opacity += 3; | |
if (this.opacity >= this.maxOpacity) { | |
return this.updateOpacityChange = this.updateOpacityDown; | |
} | |
} | |
}; | |
PKD_EasyPlacement.register(Sprite_GridCell); | |
})(); | |
// Generated by CoffeeScript 2.5.1 | |
(function() { | |
PKD_EasyPlacement.applyMIPatch = function() { | |
var __moveCell, __onCellClick, __onHotCellClick; | |
if (window.PKD_MI == null) { | |
return; | |
} | |
__onCellClick = PKD_MI.onInvCellClick; | |
PKD_MI.onInvCellClick = function() { | |
if (PKD_EPManager.IsEventDragStart() || PKD_EPManager.IsActive()) { | |
return; | |
} | |
return __onCellClick.call(this, ...arguments); | |
}; | |
__onHotCellClick = PKD_MI.onMapHotCellClick; | |
PKD_MI.onMapHotCellClick = function() { | |
if (PKD_EPManager.IsEventDragStart() || PKD_EPManager.IsActive()) { | |
return; | |
} | |
return __onHotCellClick.call(this, ...arguments); | |
}; | |
__moveCell = PKD_MI.startMoveCell; | |
PKD_MI.startMoveCell = function() { | |
if (PKD_EPManager.IsEventDragStart() || PKD_EPManager.IsActive()) { | |
return; | |
} | |
return __moveCell.call(this, ...arguments); | |
}; | |
}; | |
})(); | |
// Generated by CoffeeScript 2.5.1 | |
(function() { | |
PKD_PocketEvents.IsNetworkGame = function() { | |
return Imported.Alpha_NETZ === true && ANNetwork.isConnected(); | |
}; | |
// * Π‘ΠΎΠ·Π΄Π°ΡΡ (ΠΏΠΎΠΌΠ΅ΡΡΠΈΡΡ) ΡΠΎΠ±ΡΡΠΈΠ΅ ΠΎΡ Π΄ΡΡΠ³ΠΎΠ³ΠΎ ΠΈΠ³ΡΠΎΠΊΠ° (Π²Π½Π΅ΡΠ½Π΅Π΅) | |
PKD_EPManager.PlaceOuterItem = function({pItemIndex, x, y, mapId, spawnedEventId, uniqueId, marginY}) { | |
var e, item; | |
try { | |
item = this.ItemData(pItemIndex); | |
return this._SpawnEventOuter({ | |
mapId: mapId, | |
x: x, | |
y: y, | |
pItemIndex: pItemIndex, | |
eventId: item.eventId, | |
spawnedEventId: spawnedEventId, | |
// * ΠΡΠΆΠ΅Π½ ΡΡΠΎΠ±Ρ Π±ΡΠ»Π° Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡΡ Π΄ΠΎΠ±Π°Π²Π»ΡΡΡ ΡΠΎΠ±ΡΡΠΈΡ Π΄Π°ΠΆΠ΅ Π΅ΡΠ»ΠΈ | |
// * Ρ ΠΊΠ»ΠΈΠ΅Π½ΡΠΎΠ² ΡΠ°Π·Π½ΡΠΉ ΡΠ°Π·ΠΌΠ΅Ρ $gameMap._events | |
uniqueId: uniqueId, | |
marginY: marginY | |
}); | |
} catch (error) { | |
e = error; | |
return KDCore.warning(e); | |
} | |
}; | |
PKD_EPManager.GenerateUniqueId = function() { | |
var eventId, uniqueId; | |
uniqueId = $gameParty.leader().actorId() + "_" + KDCoreMini.makeid(8) + "_" + $gameMap.mapId(); | |
// * ΠΠ°ΡΠΈΡΠ° ΠΎΡ ΠΊΠΎΠΏΠΈΠΉ | |
eventId = this.FindSpawnedEventId($gameMap.mapId(), uniqueId); | |
if (eventId < 0) { | |
return uniqueId; | |
} else { | |
return PKD_EPManager.GenerateUniqueId(); | |
} | |
}; | |
// * Π‘ΠΎΠ·Π΄Π°ΡΡ (ΠΏΠΎΠΌΠ΅ΡΡΠΈΡΡ) ΡΠΎΠ±ΡΡΠΈΠ΅ Π½Π° ΠΊΠ°ΡΡΠ΅ (Π΅ΡΠ»ΠΈ ΠΊΠ°ΡΡΠ° ΡΠ°ΠΆΠ΅) ΠΈ Π·Π°ΡΠ΅Π³Π΅ΡΡΡΠΈΡΠΎΠ²Π°ΡΡ | |
//?VERSION | |
PKD_EPManager._SpawnEventOuter = function(eventData) {}; // * VERSION | |
// * Π‘ΠΎΡ ΡΠ°Π½ΠΈΡΡ ΡΠΎΡΡΠΎΡΠ½ΠΈΠ΅ ΠΏΠΎΠΌΠ΅ΡΡΠ½Π½ΠΎΠ³ΠΎ ΠΎΡ Π΄ΡΡΠ³ΠΎΠ³ΠΎ ΠΈΠ³ΡΠΎΠΊΠ° ΡΠΎΠ±ΡΡΠΈΡ | |
// * ΠΠ»ΡΡΠ΅ΡΠ½Π°ΡΠΈΠ²Π° PlaceItemOn | |
//?VERSION | |
PKD_EPManager._RegisterOuterItem = function(eventData) {}; // * VERSION | |
// * Π£Π΄Π°Π»ΠΈΡΡ Π²Π½Π΅ΡΠ½Π΅Π΅ (ΠΎΡ Π΄ΡΡΠ³ΠΎΠ³ΠΎ ΠΈΠ³ΡΠΎΠΊΠ°) ΡΠΎΠ±ΡΡΠΈΠ΅ | |
// * ΠΠ½Π°Π»ΠΎΠ³ PickUpPlacedItemByEvent | |
//?VERSION | |
PKD_EPManager.RemoveOuterItem = function() {}; // * VERSION | |
// * ΠΠ°ΠΉΡΠΈ ΡΠΎΠ±ΡΡΠΈΠ΅ ΠΏΠΎ ΡΠ½ΠΈΠΊΠ°Π»ΡΠ½ΠΎΠΌΡ ID | |
PKD_EPManager.FindSpawnedEventId = function(mapId, uniqueId) { | |
var db, eventData, i, len, mapData; | |
db = $gameSystem.pGetEPDB(); | |
mapData = db[mapId]; | |
if (mapData == null) { | |
return -1; | |
} | |
for (i = 0, len = mapData.length; i < len; i++) { | |
eventData = mapData[i]; | |
if (eventData.last() === uniqueId) { | |
return eventData[3]; | |
} | |
} | |
return -1; | |
}; | |
// * ΠΠΎΠ»ΡΡΠΈΡΡ ΡΠ½ΠΈΠΊΠ°Π»ΡΠ½ΡΠΉ ID ΡΠΎΠ±ΡΡΠΈΡ | |
PKD_EPManager.GetUniqueIdBySpawnedEvent = function(mapId, spawnedEventId) { | |
var db, eventData, i, len, mapData; | |
db = $gameSystem.pGetEPDB(); | |
mapData = db[mapId]; | |
if (mapData == null) { | |
return null; | |
} | |
for (i = 0, len = mapData.length; i < len; i++) { | |
eventData = mapData[i]; | |
if (eventData[3] === spawnedEventId && eventData.length > 3) { | |
return eventData.last(); | |
} | |
} | |
return null; | |
}; | |
// * Π‘ΠΏΠ°Π²Π½ (ΡΠ΄Π°Π»Π΅Π½ΠΈΠ΅) ΡΠΎΠ±ΡΡΠΈΠΉ, ΠΊΠΎΡΠΎΡΡΠ΅ Π±ΡΠ»ΠΈ ΡΠΎΠ·Π΄Π°Π½Ρ (ΡΠ΄Π°Π»Π΅Π½Ρ) ΠΊΠΎΠ³Π΄Π° ΡΠ΅ΠΊΡΡΠΈΠΉ ΠΈΠ³ΡΠΎΠΊ Π±ΡΠ» Π² ΠΌΠ΅Π½Ρ | |
PKD_EPManager.OnMapLoadedFromMenu = function() { | |
var db, evId, i, item, itemData, j, len, len1, mapId, ref, ref1; | |
// * ΠΡΠ»ΠΈ Π½ΠΎΠ²Π°Ρ ΠΊΠ°ΡΡΠ°, ΡΠΎ ΠΏΡΠΎΠΏΡΡΠΊΠ°Π΅ΠΌ | |
if (this.isShouldLoadEvents()) { | |
return; | |
} | |
if (!$gameTemp._requireNetEventsRefresh) { | |
return; | |
} | |
db = $gameSystem.pGetEPDB(); | |
mapId = $gameMap.mapId(); | |
if (db[mapId] == null) { | |
return; | |
} | |
ref = db[mapId]; | |
for (i = 0, len = ref.length; i < len; i++) { | |
item = ref[i]; | |
if (item == null) { | |
continue; | |
} | |
if ($gameMap.event(item[3]) == null) { | |
itemData = this.ItemData(item[0]); | |
this.Scene().pSpawnEPEvent(itemData.eventId, item[1], item[2], item[3]); | |
} | |
} | |
if ($gameTemp._peNetEventsToRemove != null) { | |
ref1 = $gameTemp._peNetEventsToRemove; | |
for (j = 0, len1 = ref1.length; j < len1; j++) { | |
evId = ref1[j]; | |
this.Scene().pUnSpawnEPEvent(evId); | |
} | |
$gameTemp._peNetEventsToRemove = []; | |
} | |
this.RestoreMargins(); | |
$gameTemp._requireNetEventsRefresh = false; | |
}; | |
// * Π‘Π΅ΡΠ΅Π²ΡΠ΅ ΠΌΠ΅ΡΠΎΠ΄Ρ (API) | |
// * =========================================== | |
PKD_EPManager.SendItemPlacedToServer = function(x, y, uniqueId, marginY) { | |
var data, e; | |
if (!PKD_PocketEvents.IsNetworkGame()) { | |
return; | |
} | |
try { | |
data = { | |
actorId: ANGameManager.myActorId(), | |
pItemIndex: $gameTemp._epPlacementItemId, | |
x, | |
y, | |
mapId: $gameMap.mapId(), | |
spawnedEventId: $gameTemp._epSpawned.eventId(), | |
uniqueId, | |
marginY | |
}; | |
nAPI.sendCustomCommand("pkdPE:PlaceOuterItem", data); | |
} catch (error) { | |
e = error; | |
KDCore.warning(e); | |
} | |
}; | |
PKD_EPManager.SendItemRemovedToServer = function(spawnedEventId, uniqueId) { | |
var data; | |
if (!PKD_PocketEvents.IsNetworkGame()) { | |
return; | |
} | |
data = { | |
actorId: ANGameManager.myActorId(), | |
mapId: $gameMap.mapId(), | |
uniqueId, | |
spawnedEventId | |
}; | |
return nAPI.sendCustomCommand("pkdPE:RemoveOuterItem", data); | |
}; | |
//@[OUTER] | |
PKD_EPManager.PlaceOuterItemFromServer = function(data) { | |
var e; | |
if (data == null) { | |
return; | |
} | |
try { | |
if (data.actorId === ANGameManager.myActorId()) { | |
return; | |
} | |
return PKD_EPManager.PlaceOuterItem(data); | |
} catch (error) { | |
e = error; | |
return KDCore.warning(e); | |
} | |
}; | |
//@[OUTER] | |
PKD_EPManager.RemoveOuterItemFromServer = function(data) { | |
var e; | |
if (data == null) { | |
return; | |
} | |
try { | |
if (data.actorId === ANGameManager.myActorId()) { | |
return; | |
} | |
return PKD_EPManager.RemoveOuterItem(data); | |
} catch (error) { | |
e = error; | |
return KDCore.warning(e); | |
} | |
}; | |
// * Π Π°ΡΡΠΈΡΠ΅Π½ΠΈΠ΅ ΠΌΠ΅ΡΠΎΠ΄ΠΎΠ² | |
// * ------------------------------------------- | |
PKD_EasyPlacement.applyNETZPatch = function() { | |
var __aliasFixNET06, _alias_nAPI_onCustomCommand_PE4444; | |
__aliasFixNET06 = ANMapManager.sendEventMove; | |
ANMapManager.sendEventMove = function(eventId) { | |
var event; | |
event = $gameMap.event(eventId); | |
if (event == null) { | |
return; | |
} | |
__aliasFixNET06.call(this, eventId); | |
}; | |
_alias_nAPI_onCustomCommand_PE4444 = nAPI.onCustomCommand; | |
nAPI.onCustomCommand = function(name, data) { | |
_alias_nAPI_onCustomCommand_PE4444.call(this, ...arguments); | |
if (name === "pkdPE:PlaceOuterItem") { | |
return PKD_EPManager.PlaceOuterItemFromServer(data); | |
} else if (name === "pkdPE:RemoveOuterItem") { | |
return PKD_EPManager.RemoveOuterItemFromServer(data); | |
} | |
}; | |
}; | |
})(); | |
(function(){ | |
DataManager.pLoadEPEventData = function () { | |
var mapId = PKD_EasyPlacement.ITEMS_MAP; | |
if (mapId > 0) { | |
var filename = 'Map%1.json'.format(mapId.padZero(3)); | |
this.loadDataFile('$dataEPEventsMap', filename); | |
} else { | |
console.warn("EasyPlacement.js: You didn't set a map ID for placement events!"); | |
window.alert("EasyPlacement.js: You didn't set a map ID for placement events!"); | |
} | |
}; | |
//@[ALIAS] | |
var _alias_DataManager_loadDatabase = DataManager.loadDatabase; | |
DataManager.loadDatabase = function () { | |
PKD_EasyPlacement.LoadPluginSettings(); | |
DataManager.pLoadEPEventData(); | |
_alias_DataManager_loadDatabase.call(this); | |
}; | |
})(); | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Game_CharacterBase.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var _; | |
//@[DEFINES] | |
_ = Game_CharacterBase.prototype; | |
// * DUMMY | |
_.pGetEPDynamicObjId = function() { | |
return -1; | |
}; | |
// * DUMMY | |
_.epIsDraggable = function() { | |
return false; | |
}; | |
})(); | |
// β END Game_CharacterBase.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Game_Event.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__clearPageSettings, ALIAS__setupPageSettings, _; | |
//@[DEFINES] | |
_ = Game_Event.prototype; | |
//@[ALIAS] | |
ALIAS__setupPageSettings = _.setupPageSettings; | |
_.setupPageSettings = function() { | |
var e; | |
ALIAS__setupPageSettings.call(this); | |
try { | |
// * Π Π²Π΅ΡΡΠΈΠΈ 1.3. Π² ΡΠ΅ΡΠ΅Π²ΠΎΠΉ ΠΈΠ³ΡΠ΅ Draggable ΠΎΡΠΊΠ»ΡΡΡΠ½ (Π²ΡΠ΅ΠΌΠ΅Π½Π½ΠΎ) | |
if (PKD_EasyPlacement.PARAMS.ALLOW_DRAG === true && !PKD_PocketEvents.IsNetworkGame()) { | |
this._epDragDataId = PKD_EPManager.ExtractDraggableEventComment(this.list()); | |
this._epIsDraggableEvent = (this._epDragDataId != null) && this._epDragDataId > 0; | |
if (this._epIsDraggableEvent === true) { | |
return this.epSetupDragEvent(); | |
} | |
} else { | |
return this._epIsDraggableEvent = false; | |
} | |
} catch (error) { | |
e = error; | |
this._epIsDraggableEvent = false; | |
return console.warn(e); | |
} | |
}; | |
//@[ALIAS] | |
ALIAS__clearPageSettings = _.clearPageSettings; | |
_.clearPageSettings = function() { | |
ALIAS__clearPageSettings.call(this); | |
return this._epIsDraggableEvent = false; | |
}; | |
// * ΠΡΠΎΡΠΈΠ΅ Π½Π°ΡΡΡΠΎΠΉΠΊΠΈ ΠΏΠ΅ΡΠ΅ΠΌΠ΅ΡΠ΅Π½ΠΈΡ ΠΈΠ· ΠΏΠ°ΡΠ°ΠΌΠ΅ΡΡΠΎΠ² ΠΏΠ»Π°Π³ΠΈΠ½Π° | |
_.epSetupDragEvent = function() { | |
var e; | |
try { | |
this._epDragData = PKD_EasyPlacement.PARAMS.DRAG_ITEMS[this._epDragDataId]; | |
this._epIsDraggableEvent = this._epDragData != null; | |
} catch (error) { | |
e = error; | |
console.warn(e); | |
} | |
}; | |
_.epIsDraggable = function() { | |
return this._epIsDraggableEvent === true; | |
}; | |
// * ΠΠ°ΡΠ°ΠΌΠ΅ΡΡΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅ΡΠ΅Π½ΠΈΡ (ΡΠ΅ΡΠΊΠ°, ΡΠ΅Π³ΠΈΠΎΠ½, ΡΠΌΠ΅Π½Π° ΠΊΠ°ΡΡΠΈΠ½ΠΊΠΈ, ΠΏΠ΅ΡΠ΅ΠΌΠ΅ΡΠ΅Π½ΠΈΠ΅ Π½Π° Π΄ΡΡΠ³ΠΈΠ΅ ΡΠΎΠ±ΡΡΠΈΡ) | |
_.epGetDragSettings = function() { | |
return {}; | |
}; | |
// * ΠΠΎΠ³Π΄Π° ΠΈΠ³ΡΠΎΠΊ Π½Π°ΡΠ°Π» Π΄Π²ΠΈΠ³Π°ΡΡ ΡΠΎΠ±ΡΡΠΈΠ΅ | |
_.pOnDragStart = function() { | |
var e; | |
$gameTemp._epSpawnModeOverEvents = this._epDragData.canSpawnOverEvents === true; | |
PKD_EPManager.SetGridVisibility(this._epDragData.gridVisiblity); | |
// * Π ΡΠ΅ΡΠ΅Π²ΠΎΠΉ ΠΈΠ³ΡΠ΅ ΠΏΠ°ΡΠ·Π° ΠΈΠ³ΡΡ Π½Π΅Π΄ΠΎΡΡΡΠΏΠ½Π° | |
$gameTemp.pPauseMap = this._epDragData.isShouldPauseMap && !PKD_PocketEvents.IsNetworkGame(); | |
this._opacity = 200; | |
try { | |
if (this._epDragData.image == null) { | |
return; | |
} | |
this._pStoredImageData = {}; | |
this._pStoredImageData.characterIndex = this._characterIndex; | |
this._pStoredImageData.characterName = this._characterName; | |
this.pOnDragImageChange(this._epDragData.image); | |
} catch (error) { | |
e = error; | |
console.warn(e); | |
} | |
}; | |
_.pOnDragImageChange = function(imageData) { | |
if (imageData == null) { | |
return; | |
} | |
if (imageData.characterName == null) { | |
return; | |
} | |
if (imageData.characterName === "") { | |
return; | |
} | |
return this.setImage(imageData.characterName, imageData.characterIndex); | |
}; | |
// * ΠΠΎΠ³Π΄Π° ΠΈΠ³ΡΠΎΠΊ ΠΎΡΠΏΡΡΡΠΈΠ» ΠΌΡΡΠΊΡ (Π·Π°ΠΊΠΎΠ½ΡΠΈΡΡ ΠΏΠ΅ΡΠ΅ΠΌΠ΅ΡΠ΅Π½ΠΈΠ΅) | |
_.pOnDragEnd = function() { | |
var x, y; | |
PKD_EPManager.SetGridVisibility(false); | |
this._opacity = 255; | |
this.pOnDragImageChange(this._pStoredImageData); | |
this._pStoredImageData = null; | |
if (PKD_EPManager.IsPointIsGoodForDrag()) { | |
({x, y} = TouchInput.mapPoint()); | |
this.locate(x, y); | |
$gameSystem.pSaveDraggableEventPosition(this.eventId(), this.x, this.y); | |
if (this._epDragData.ceSpawnGood > 0) { | |
$gameTemp.reserveCommonEvent(this._epDragData.ceSpawnGood); | |
} | |
} else { | |
SoundManager.playBuzzer(); | |
} | |
// * just return to own place | |
$gameTemp._epSpawnModeOverEvents = false; | |
}; | |
_.pOnDragCheckRegion = function(x, y) { | |
var region; | |
region = $gameMap.regionId(x, y); | |
return !this._epDragData.exceptRegions.contains(region); | |
}; | |
_.pIsFacingPlayer = function() { | |
var dir, x, y; | |
({x, y} = $gamePlayer); | |
dir = $gamePlayer.direction(); | |
switch (dir) { | |
case 8: | |
y -= 1; | |
break; | |
case 6: | |
x += 1; | |
break; | |
case 4: | |
x -= 1; | |
break; | |
default: | |
y += 1; | |
} | |
return this.pos(x, y); | |
}; | |
_.setEPMargins = function(epMX, epMY) { | |
this.epMX = epMX; | |
this.epMY = epMY; | |
}; | |
// * X ΠΏΠΎΠΊΠ° Π½Π΅ ΡΡΠΈΡΡΠ²Π°Π΅ΡΡΡ | |
_.pOnMargin = function(x, y) { | |
var _prevMY, itemSettings, step; | |
itemSettings = PKD_EPManager.CurrentPlacementItemData(); | |
if (itemSettings == null) { | |
return; | |
} | |
if (!itemSettings.allowMargin) { | |
return; | |
} | |
if (this.epMY == null) { | |
this.epMY = 0; | |
} | |
step = itemSettings.marginStep; | |
_prevMY = this.epMY; | |
this.epMY += y * step; | |
if (this.epMY <= itemSettings.marginMin || this.epMY >= itemSettings.marginMax) { | |
this.epMY = _prevMY; | |
} else { | |
$gameSystem.pSaveEPMargins($gameMap.mapId(), this.eventId(), 0, this.epMY); | |
} | |
}; | |
})(); | |
// β END Game_Event.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Game_Map.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__setup, ALIAS__update, _; | |
//@[DEFINES] | |
_ = Game_Map.prototype; | |
//@[ALIAS] | |
ALIAS__setup = _.setup; | |
_.setup = function(mapId) { | |
ALIAS__setup.call(this, mapId); | |
return PKD_EPManager.OnNextMapLoaded(); | |
}; | |
_.pGetDraggableEventInTouchPoint = function() { | |
var events, x, y; | |
events = this.pGetAllDraggableEvents(); | |
if (events.length > 0) { | |
({x, y} = TouchInput.mapPoint()); | |
return events.find(function(e) { | |
return e.pos(x, y); | |
}); | |
} | |
//return @eventsXy(x, y).find (e) -> e.epIsDraggable() | |
return null; | |
}; | |
_.pGetAllDraggableEvents = function() { | |
return this.events().filter(function(e) { | |
return e.epIsDraggable(); | |
}); | |
}; | |
//@[ALIAS] | |
ALIAS__update = _.update; | |
_.update = function(sceneActive) { | |
if ((PKD_EPManager.IsEventDragStart() || PKD_EPManager.IsActive()) && $gameTemp.pPauseMap === true) { | |
} else { | |
return ALIAS__update.call(this, sceneActive); | |
} | |
}; | |
})(); | |
// β END Game_Map.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Game_Player.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__canMove, _; | |
//@[DEFINES] | |
_ = Game_Player.prototype; | |
//@[ALIAS] | |
ALIAS__canMove = _.canMove; | |
_.canMove = function() { | |
if (PKD_EasyPlacement.PARAMS.ALLOW_ARROW_MOVE === true && PKD_EPManager.IsActive()) { | |
return false; | |
} else if (PKD_EPManager.IsEventDragStart()) { | |
return false; | |
} else { | |
return ALIAS__canMove.call(this, ...arguments); | |
} | |
}; | |
})(); | |
// β END Game_Player.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Game_System.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__initialize, _; | |
//@[DEFINES] | |
_ = Game_System.prototype; | |
//@[ALIAS] | |
ALIAS__initialize = _.initialize; | |
_.initialize = function() { | |
ALIAS__initialize.call(this); | |
this.pGetEPDB(); // * Pocket Events storage | |
this.pGetEPDB2(); // * Draggable positions | |
return this.pGetEPDB3(); // * Π‘ΠΌΠ΅ΡΠ΅Π½ΠΈΠ΅ | |
}; | |
_.pGetEPDB = function() { | |
if (this.pEPDB == null) { | |
this.pEPDB = {}; | |
} | |
return this.pEPDB; | |
}; | |
_.pGetEPDB2 = function() { | |
if (this.pEPDB2 == null) { | |
this.pEPDB2 = {}; | |
} | |
return this.pEPDB2; | |
}; | |
_.pGetEPDB3 = function() { | |
if (this.pEPDB3 == null) { | |
this.pEPDB3 = {}; | |
} | |
return this.pEPDB3; | |
}; | |
_.pRegisterEPItem = function(mapId, itemId, x, y, eventId) { | |
var db; | |
// * Π Π΅Π³Π΅ΡΡΡΠΈΡΡΠ΅Ρ ΡΠΎΠ·Π΄Π°Π½Π½ΡΠΉ | |
db = this.pGetEPDB(); | |
if (db[mapId] == null) { | |
db[mapId] = []; | |
} | |
db[mapId].push([itemId, x, y, eventId]); | |
//"REGISTER".p(itemId) | |
return db[mapId].last(); | |
}; | |
_.pRemoveEPItem = function(mapId, eventId) { | |
var db, i, item, itemToDelete, len, ref; | |
// * Π£Π΄Π°Π»ΡΠ΅Ρ ΡΠΎΠ·Π΄Π°Π½Π½ΡΠ΅ | |
db = this.pGetEPDB(); | |
if (db[mapId] == null) { | |
return; | |
} | |
itemToDelete = null; | |
ref = db[mapId]; | |
for (i = 0, len = ref.length; i < len; i++) { | |
item = ref[i]; | |
//if item[1] is x && item[2] is y | |
// itemToDelete = item | |
if (item[3] === eventId) { | |
itemToDelete = item; | |
} | |
} | |
if (itemToDelete == null) { | |
return; | |
} | |
db[mapId].delete(itemToDelete); | |
this.pRemoveEPMargins(mapId, eventId); | |
}; | |
_.pSaveDraggableEventPosition = function(eventId, x, y) { | |
var db, mapId; | |
// * Π‘ΠΎΡ ΡΠ°Π½ΡΠ΅Ρ ΠΏΠΎΠ·ΠΈΡΠΈΡ | |
db = this.pGetEPDB2(); | |
mapId = $gameMap.mapId(); | |
if (db[mapId] == null) { | |
db[mapId] = []; | |
} | |
db[mapId].push([eventId, x, y]); | |
}; | |
_.pRestoreDraggableEventsPositions = function() { | |
var db, i, len, mapId, position, ref; | |
// * ΠΠΎΠ·Π²ΡΠ°ΡΠ°Π΅Ρ ΠΏΠΎΠ·ΠΈΡΠΈΡ | |
db = this.pGetEPDB2(); | |
mapId = $gameMap.mapId(); | |
if (db[mapId] == null) { | |
return; | |
} | |
ref = db[mapId]; | |
for (i = 0, len = ref.length; i < len; i++) { | |
position = ref[i]; | |
if (position == null) { | |
continue; | |
} | |
$gameMap.event(position[0]).setPosition(position[1], position[2]); | |
} | |
}; | |
_.pSaveEPMargins = function(mapId, eventId, x, y) { | |
var db; | |
db = this.pGetEPDB3(); | |
if (db[mapId] == null) { | |
db[mapId] = []; | |
} | |
db[mapId].push([eventId, x, y]); | |
}; | |
_.pRemoveEPMargins = function(mapId, eventId) { | |
var db, eventToDelete; | |
db = this.pGetEPDB3(); | |
if (db[mapId] == null) { | |
return; | |
} | |
eventToDelete = db[mapId].find(function(item) { | |
return item[3] === eventId; | |
}); | |
if (eventToDelete == null) { | |
return; | |
} | |
db[mapId].delete(eventToDelete); | |
}; | |
_.pRestoreEPMargins = function() { | |
var db, event, i, len, mapId, margin, ref; | |
db = this.pGetEPDB3(); | |
mapId = $gameMap.mapId(); | |
if (db[mapId] == null) { | |
return null; | |
} | |
ref = db[mapId]; | |
for (i = 0, len = ref.length; i < len; i++) { | |
margin = ref[i]; | |
if (margin == null) { | |
continue; | |
} | |
event = $gameMap.event(margin[0]); | |
if (event == null) { | |
continue; | |
} | |
event.setEPMargins(margin[1], margin[2]); | |
} | |
}; | |
})(); | |
// β END Game_System.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Scene_Map.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__isMenuEnabled, ALIAS__onMapLoaded, ALIAS__processMapTouch, ALIAS__update, ALIAS__updateDestination, _; | |
//@[DEFINES] | |
_ = Scene_Map.prototype; | |
// * evId - event to spawn and move | |
_.pActivateEPMode = function(evId) { | |
this._pInEPMode = true; | |
this._pIsSetupOk = false; // * User place Event? | |
$gameTemp._epSpawned = this.pSpawnEPEvent(evId, 0, 0, $gameMap._events.length); | |
}; | |
_.pEndEPMode = function() { | |
if (this._pIsSetupOk === false) { | |
PKD_EPManager.CallCancelCommonEvent(); | |
this.pUnSpawnEPEvent($gameTemp._epSpawned._eventId); | |
} | |
$gameTemp._epSpawned = null; | |
return this._pInEPMode = false; | |
}; | |
_.pIsEPMode = function() { | |
return this._pInEPMode === true; | |
}; | |
_.pSpawnEPEvent = function(evId, x, y, newEvId) { | |
var ev, ref; | |
if (newEvId == null) { | |
newEvId = $gameMap._events.length; | |
} | |
ev = new Game_EPEvent(evId, newEvId, $gameTemp._epPlacementItemId); | |
$gameMap._events[newEvId] = ev; | |
if (Imported.VisuMZ_1_EventsMoveCore === true) { | |
if ((ref = $gameMap._eventCache) != null) { | |
ref.push(ev); | |
} | |
} | |
this._spriteset.pAddNewPlacementEvent(ev._eventId); | |
ev.setPosition(x, y); | |
return ev; | |
}; | |
_.pUnSpawnEPEvent = function(evId) { | |
var event, ref; | |
event = $gameMap.event(evId); | |
if (event == null) { | |
return; | |
} | |
this._spriteset.pRemovePlacementEvent(evId); | |
PKD_EPManager.ClearSelfSwitches($gameMap.mapId(), evId); | |
$gameMap._events[evId] = null; | |
if (Imported.VisuMZ_1_EventsMoveCore === true) { | |
if ((ref = $gameMap._eventCache) != null) { | |
ref.delete(event); | |
} | |
} | |
$gameMap.requestRefresh(); | |
}; | |
//@[ALIAS] | |
ALIAS__onMapLoaded = _.onMapLoaded; | |
_.onMapLoaded = function() { | |
ALIAS__onMapLoaded.call(this); | |
// * ΠΡΠ»ΠΈ Π±ΡΠ»ΠΈ ΡΠΎΠ·Π΄Π°Π½Ρ ΡΠΎΠ±ΡΡΠΈΡ, ΠΏΠΎΠΊΠ° ΠΈΠ³ΡΠΎΠΊ Π±ΡΠ» Π½Π° Π΄ΡΡΠ³ΠΎΠΉ ΡΡΠ΅Π½Π΅ (ΠΌΠ΅Π½Ρ) | |
if (PKD_PocketEvents.IsNetworkGame()) { | |
PKD_EPManager.OnMapLoadedFromMenu(); | |
} | |
PKD_EPManager.OnMapLoaded(); | |
}; | |
//@[ALIAS] | |
ALIAS__updateDestination = _.updateDestination; | |
_.updateDestination = function() { | |
if (this.pIsEPMode()) { | |
if (!$gamePlayer.isMoving()) { | |
$gamePlayer.turnTowardCharacter(TouchInput.mapPoint()); | |
} | |
} else { | |
return ALIAS__updateDestination.call(this); | |
} | |
}; | |
//@[ALIAS] | |
ALIAS__isMenuEnabled = _.isMenuEnabled; | |
_.isMenuEnabled = function() { | |
if (this.pIsEPMode() || PKD_EPManager.IsEventDragStart()) { | |
return false; | |
} else { | |
return ALIAS__isMenuEnabled.call(this); | |
} | |
}; | |
//@[ALIAS] | |
ALIAS__update = _.update; | |
_.update = function() { | |
ALIAS__update.call(this); | |
if (this.pIsEPMode()) { | |
this.pUpdateEPArrowMove(); | |
this.pUpdateEPCommon(); | |
this.pUpdateMarginsScroll(); | |
} else { | |
if (PKD_EPManager.IsEventDragStart()) { | |
this.pCheckDragStop(); | |
} | |
} | |
}; | |
//@[ALIAS] | |
ALIAS__processMapTouch = _.processMapTouch; | |
_.processMapTouch = function() { | |
if (this.pIsEPMode()) { // * Π ΡΠ΅ΠΆΠΈΠΌΠ΅ placement Π½Π΅Π»ΡΠ·Ρ draggable events movement! | |
return ALIAS__processMapTouch.call(this); | |
} else { | |
this.pProcessMapEventDragging(); | |
if (!PKD_EPManager.IsEventDragStart()) { | |
return ALIAS__processMapTouch.call(this); | |
} | |
} | |
}; | |
//?DYNAMIC | |
_.pProcessMapEventDragging = function() { | |
var draggable; | |
if ($gameMessage.isBusy()) { | |
return; | |
} | |
draggable = PKD_EPManager.GetDraggableEventUnderMouse(); | |
if (draggable == null) { | |
return; | |
} | |
if (draggable.pIsFacingPlayer()) { | |
if (TouchInput.isLongPressed()) { | |
this.pCheckDraggableEventUnderMouse(); | |
} | |
} else { | |
if (TouchInput.isPressed()) { | |
this.pCheckDraggableEventUnderMouse(); | |
} | |
} | |
}; | |
_.pCheckDraggableEventUnderMouse = function() { | |
if (!PKD_EPManager.IsEventDragStart()) { | |
PKD_EPManager.StartEventDrag(); // * ΠΠΎΠΆΠ΅Ρ Π½Π΅ Π²ΡΠΏΠΎΠ»Π½ΠΈΡΡΡΡ, Π΅ΡΠ»ΠΈ Π½Π΅Ρ ΠΏΠΎΠ΄ ΠΊΡΡΡΠΎΡΠΎΠΌ ΡΠΎΠ±ΡΡΠΈΡ | |
} | |
}; | |
_.pCheckDragStop = function() { | |
if (TouchInput.isReleased()) { | |
PKD_EPManager.OnEventDragEnd(); | |
} | |
}; | |
_.pGetDraggableEventInTouchPoint = function() { | |
return this._spriteset.pGetDraggableEventInTouchPoint(); | |
}; | |
_.pOnDragStart = function() { | |
if ($gameTemp.pLastDraggableEvent == null) { | |
return; | |
} | |
$gameTemp.clearDestination(); | |
this._spriteset.pSetDraggableEventState($gameTemp.pLastDraggableEvent, true); | |
$gameTemp.pLastDraggableEvent.pOnDragStart(); | |
}; | |
_.pOnDragEnd = function() { | |
if ($gameTemp.pLastDraggableEvent == null) { | |
return; | |
} | |
$gameTemp.pLastDraggableEvent.pOnDragEnd(); | |
this._spriteset.pSetDraggableEventState($gameTemp.pLastDraggableEvent, false); | |
}; | |
_.pUpdateEPCommon = function() { | |
var x, y; | |
if (this.isMenuCalled()) { | |
return PKD_EPManager.Stop(); | |
} else { | |
if (!this.__pLTIX || (this.__pLTIX !== TouchInput.x || this.__pLTIY !== TouchInput.y)) { | |
({x, y} = TouchInput.mapPoint()); | |
$gameTemp._epSpawned.setPosition(x, y); | |
this.__pLTIX = null; // * ΠΠΎΡΡΠ°ΡΠΎΡΠ½ΠΎ ΡΠ±ΡΠΎΡΠΈΡΡ X | |
} else { | |
} | |
// * NO MOVING BY MOUSE (arrow key moving before) | |
if (TouchInput.isTriggered() || Input.isTriggered('ok')) { | |
if (PKD_EPManager.IsPointIsGood()) { | |
this.pPlaceEPItemOnSpot(x, y); | |
return PKD_EPManager.Stop(); | |
} else { | |
return SoundManager.playBuzzer(); | |
} | |
} | |
} | |
}; | |
_.pUpdateMarginsScroll = function() { | |
var threshold; | |
threshold = 20; | |
if (TouchInput.wheelY >= threshold) { | |
$gameTemp._epSpawned.pOnMargin(0, -1); | |
} else if (TouchInput.wheelY <= -threshold) { | |
$gameTemp._epSpawned.pOnMargin(0, +1); | |
} | |
}; | |
_.pUpdateEPArrowMove = function() { | |
if (!PKD_EasyPlacement.PARAMS.ALLOW_ARROW_MOVE) { | |
return; | |
} | |
if ($gameTemp._epSpawned == null) { | |
return; | |
} | |
if (Input.isRepeated('left')) { | |
this.pMoveSpawnedByArrowKey(-1, 0); | |
} | |
if (Input.isRepeated('right')) { | |
this.pMoveSpawnedByArrowKey(1, 0); | |
} | |
if (Input.isRepeated('down')) { | |
this.pMoveSpawnedByArrowKey(0, 1); | |
} | |
if (Input.isRepeated('up')) { | |
this.pMoveSpawnedByArrowKey(0, -1); | |
} | |
}; | |
_.pSetMouseLockWhenArrowMove = function() { | |
var x, y; | |
({x, y} = TouchInput); | |
this.__pLTIX = x; | |
return this.__pLTIY = y; | |
}; | |
_.pMoveSpawnedByArrowKey = function(dx, dy) { | |
var x, y; | |
this.pSetMouseLockWhenArrowMove(); | |
({x, y} = $gameTemp._epSpawned); | |
$gameTemp._epSpawned.setPosition(x + dx, y + dy); | |
}; | |
_.pPlaceEPItemOnSpot = function(x, y) { | |
PKD_EPManager.PlaceItemOn(x, y); | |
return this._pIsSetupOk = true; | |
}; | |
})(); | |
// β END Scene_Map.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Sprite_Character.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__initMembers, ALIAS__updatePosition, _; | |
//@[DEFINES] | |
_ = Sprite_Character.prototype; | |
//@[ALIAS] | |
ALIAS__initMembers = _.initMembers; | |
_.initMembers = function() { | |
ALIAS__initMembers.call(this); | |
return this.p_dragMode = false; | |
}; | |
_.pSetDragMode = function(p_dragMode) { | |
this.p_dragMode = p_dragMode; | |
}; | |
//@[ALIAS] | |
ALIAS__updatePosition = _.updatePosition; | |
_.updatePosition = function() { | |
if (this.p_dragMode === true) { | |
this.x = TouchInput.x; | |
this.y = TouchInput.y; | |
this.z = this._character.screenZ(); | |
} else { | |
ALIAS__updatePosition.call(this); | |
} | |
// * Π‘ΠΌΠ΅ΡΠ΅Π½ΠΈΠ΅ ΠΏΠΎ Y, ΠΏΠΎ X Π½Π΅ ΡΡΠΈΡΡΠ²Π°Π΅ΠΌ ΠΏΠΎΠΊΠ° ΡΡΠΎ | |
if (this._character.epMY != null) { | |
this.y += this._character.epMY; | |
} | |
}; | |
})(); | |
// β END Sprite_Character.coffee | |
//--------------------------------------------------------------------------- | |
// Generated by CoffeeScript 2.5.1 | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
// β Spriteset_Map.coffee | |
//βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
//--------------------------------------------------------------------------- | |
(function() { | |
var ALIAS__createTilemap, ALIAS__update, _; | |
//@[DEFINES] | |
_ = Spriteset_Map.prototype; | |
//@[ALIAS] | |
ALIAS__createTilemap = _.createTilemap; | |
_.createTilemap = function() { | |
ALIAS__createTilemap.call(this); | |
return this.pCreateEPGrid(); | |
}; | |
//@[ALIAS] | |
ALIAS__update = _.update; | |
_.update = function() { | |
ALIAS__update.call(this); | |
return this.pUpdateEPGridLayer(); | |
}; | |
_.pCreateEPGrid = function() { | |
var bitmap; | |
this._pEPGridLayer = new Sprite(); | |
this._pEPGridLayer.opacity = 50; | |
bitmap = new Bitmap($gameMap.width() * $gameMap.tileWidth(), $gameMap.height() * $gameMap.tileHeight()); | |
this._pEPGridLayer.bitmap = bitmap; | |
bitmap.addLoadListener(this.pDrawEPGrid.bind(this)); | |
this._pEPGridLayer.z = 1; | |
this._tilemap.addChild(this._pEPGridLayer); | |
return this.pCreateEPHoverCell(); | |
}; | |
_.pCreateEPHoverCell = function() { | |
this._pEPCell = new PKD_EasyPlacement.LIBS.Sprite_GridCell(); | |
return this._tilemap.addChild(this._pEPCell); | |
}; | |
_.pDrawEPGrid = function() { | |
var drawLineHor, drawLineVert, i, j, k, l, ref, ref1, results; | |
drawLineVert = function(b, i) { | |
return b.fillRect(0, i * $gameMap.tileWidth(), b.width, 1, 'rgba(0, 0, 0, 1)'); | |
}; | |
drawLineHor = function(b, i) { | |
return b.fillRect(i * $gameMap.tileHeight(), 0, 1, b.height, 'rgba(0, 0, 0, 1)'); | |
}; | |
for (i = k = 0, ref = $gameMap.height(); (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) { | |
drawLineVert(this._pEPGridLayer.bitmap, i); | |
} | |
results = []; | |
for (j = l = 0, ref1 = $gameMap.width(); (0 <= ref1 ? l < ref1 : l > ref1); j = 0 <= ref1 ? ++l : --l) { | |
results.push(drawLineHor(this._pEPGridLayer.bitmap, j)); | |
} | |
return results; | |
}; | |
_.pUpdateEPGridLayer = function() { | |
var screenTouchPoint, screenX, screenY, th, tw, tw2; | |
this._pEPGridLayer.visible = PKD_EPManager.IsGridVisible(); | |
this._pEPCell.visible = PKD_EPManager.IsGridVisible(); | |
if (!this._pEPGridLayer.visible) { | |
return; | |
} | |
if (this._pEPGridLayer == null) { | |
return; | |
} | |
tw = $gameMap.tileWidth(); | |
tw2 = tw / 2; | |
th = $gameMap.tileHeight(); | |
screenX = Math.round($gameMap.adjustX(-0.5) * tw + tw2); | |
screenY = Math.round($gameMap.adjustY(-1) * th + th); | |
this._pEPGridLayer.move(screenX, screenY); | |
// * Π’Π°ΠΊ ΠΊΠ°ΠΊ Π΄ΠΎΠ±Π°Π²Π»Π΅Π½Π° Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡΡ Π΄Π²ΠΈΠ³Π°ΡΡ ΡΡΡΠ΅Π»Π°ΠΌΠΈ, ΡΠΎ Π±Π΅ΡΡΠΌ ΠΊΠΎΠΎΡΠ΄ΠΈΠ½Π°ΡΡ $gameTemp._epSpawned | |
if (PKD_EPManager.IsActive()) { | |
screenTouchPoint = $gameTemp._epSpawned; | |
if (screenTouchPoint == null) { | |
return; | |
} | |
this._pEPCell.move(screenTouchPoint.screenX(), screenTouchPoint.screenY()); | |
} else { | |
screenTouchPoint = TouchInput.mapScreenPoint(); | |
this._pEPCell.move(screenTouchPoint.x, screenTouchPoint.y); | |
} | |
}; | |
_.pAddNewPlacementEvent = function(id) { | |
var event, spr; | |
event = $gameMap._events[id]; | |
spr = new Sprite_Character(event); | |
this._characterSprites.push(spr); | |
this._tilemap.addChild(spr); | |
spr.update(); | |
}; | |
_.pRemovePlacementEvent = function(id) { | |
var spr; | |
spr = this._characterSprites.find(function(i) { | |
return (i._character != null) && i._character.pGetEPDynamicObjId() >= 0 && i._character._eventId === id; | |
}); | |
if (spr == null) { | |
return; | |
} | |
spr.visible = false; | |
this._characterSprites.delete(spr); | |
//for animSpr in spr._animationSprites | |
// @_tilemap.removeChild animSpr | |
this._tilemap.removeChild(spr); | |
}; | |
_.pGetDraggableEventInTouchPoint = function() { | |
var events, k, len, s, sprites; | |
events = $gameMap.pGetAllDraggableEvents(); | |
if (events.length > 0) { | |
sprites = events.map((e) => { | |
return this.findTargetSprite(e); | |
}); | |
for (k = 0, len = sprites.length; k < len; k++) { | |
s = sprites[k]; | |
if (this.pTouchInEvDragRect(s)) { | |
return s._character; | |
} | |
} | |
} | |
return null; | |
}; | |
_.pTouchInEvDragRect = function(item) { | |
var bRealX, bRealY, x, y; | |
({x, y} = TouchInput); | |
bRealX = item.x - item._frame.width / 2; | |
bRealY = item.y - item._frame.height; | |
return x >= bRealX && y >= bRealY && x < bRealX + item.width && y < item.height + bRealY; | |
}; | |
_.pSetDraggableEventState = function(event, state) { | |
var sprite; | |
sprite = this.findTargetSprite(event); | |
sprite.pSetDragMode(state); | |
}; | |
})(); | |
// β END Spriteset_Map.coffee | |
//--------------------------------------------------------------------------- | |
//Plugin PKD_PocketEvents automatic build by PKD PluginBuilder 1.9.2 20.11.2021 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment