code
stringlengths 2
1.05M
|
|---|
var NgUploaderOptions = (function () {
function NgUploaderOptions(obj) {
function use(source, defaultValue) {
return obj && source !== undefined ? source : defaultValue;
}
this.url = use(obj.url, '');
this.cors = use(obj.cors, true);
this.withCredentials = use(obj.withCredentials, false);
this.multiple = use(obj.multiple, true);
this.maxUploads = use(obj.maxUploads, 10);
this.data = use(obj.data, {});
this.autoUpload = use(obj.autoUpload, true);
this.multipart = use(obj.multipart, true);
this.method = use(obj.method, 'POST');
this.customHeaders = use(obj.customHeaders, {});
this.encodeHeaders = use(obj.encodeHeaders, false);
this.filenameHeader = use(obj.filenameHeader, undefined);
this.authTokenPrefix = use(obj.authTokenPrefix, 'Bearer');
this.authToken = use(obj.authToken, undefined);
this.fieldName = use(obj.fieldName, 'file');
this.fieldReset = use(obj.fieldReset, true);
this.previewUrl = use(obj.previewUrl, false);
this.calculateSpeed = use(obj.calculateSpeed, true);
this.filterExtensions = use(obj.filterExtensions, false);
this.allowedExtensions = use(obj.allowedExtensions, []);
this.maxSize = use(obj.maxSize, undefined);
}
return NgUploaderOptions;
}());
export { NgUploaderOptions };
//# sourceMappingURL=ng-uploader-options.class.js.map
|
'use strict';
angular.module('web-push-angular', [])
.factory('webPush', ['$rootScope',
function ($rootScope) {
function PusherAngular (pusherClient) {
if (!(this instanceof PusherAngular)) {
return new PusherAngular(pusherClient);
}
this._assertValidClient(pusherClient);
this.client = pusherClient;
this.connection = $connection(pusherClient.connection, pusherClient);
this.channels = {};
}
PusherAngular.prototype = {
/**
* Subscribe the client to the specified channelName and returns the channel object.
* {@link https://pusher.com/docs/client_api_guide/client_public_channels#subscribe}
*
* @param {String} channelName name of the channel
* @returns {Object} channel object
*/
subscribe: function (channelName) {
var channel = $channel(this.client.subscribe(channelName), this);
this.channels[channelName] = channel;
return channel;
},
/**
* Unsubscribes the client from the specified channel
* {@link https://pusher.com/docs/client_api_guide/client_public_channels#unsubscribe}
*
* @param {String} channelName name of the channel
*/
unsubscribe: function (channelName) {
if (this.client.channel(channelName)) {
this.client.unsubscribe(channelName);
if (this.channels[channelName]) { delete this.channels[channelName]; }
}
},
/**
* Binds to global events on the pusher client. You can attach behaviour to these events
* regardless of the channel the event is broadcast to.
*
* @param {String} eventName name of the event you want to bind to
* @param {Function|undefined} callback callback that you want called upon the event occurring
*/
bind: function (eventName, callback) {
this.client.bind(eventName, function (data) {
callback(data);
$rootScope.$digest();
});
},
/**
* Binds to all of the global client messages.
*
* @param {Function|undefined} callback callback that you want called upon a message being received
*/
bind_all: function (callback) {
this.client.bind_all(function (eventName, data) {
callback(eventName, data);
$rootScope.$digest();
});
},
/**
* Disconnects the pusher client.
* {@link http://pusher.com/docs/client_api_guide/client_connect#disconnecting}
*/
disconnect: function () {
this.client.disconnect();
},
/**
* Returns a pusher channel object.
* {@link https://pusher.com/docs/client_api_guide/client_channels#access}
*
* @param {String} channelName name of the channel
* @returns {Array} channel object
*/
channel: function (channelName) {
return this.channels[channelName];
},
/**
* Returns a an array of the channels that the client is subscribed to.
* {@link https://pusher.com/docs/client_api_guide/client_channels#access}
*
* @returns {Array} array of subscribed channels
*/
allChannels: function () {
return this.channels;
},
/**
* Asserts that the $pusher object is being initialised with valid pusherClient.
* Throws an error if pusherClient is invalid.
*
* @param {Object} pusherClient members object from base pusher channel object
*/
_assertValidClient: function (pusherClient) {
if (!angular.isObject(pusherClient) ||
!angular.isObject(pusherClient.connection) ||
typeof(pusherClient.channel) !== 'function') {
throw new Error('Invalid Pusher client object');
}
}
}
return PusherAngular;
}
])
.factory('$channel', ['$rootScope', '$q', '$members',
function ($rootScope, $q, $members) {
function checkPresenceChannel (channelName) {
if (channelName.indexOf('presence-') == -1) { throw new Error('Presence channel required'); }
}
function $channel (baseChannel, $pusherClient) {
if (!(this instanceof $channel)) {
return new $channel(baseChannel, $pusherClient);
}
this._assertValidChannel(baseChannel);
this.baseChannel = baseChannel;
this.client = $pusherClient;
this.name = baseChannel.name;
if (baseChannel.name.indexOf('presence') == -1) {
this.members = function () { throw new Error('Members object only exists for presence channels'); }
} else {
this.members = $members(baseChannel.members, baseChannel);
}
}
$channel.prototype = {
/**
* Binds to the given event name on the channel.
*
* @param {String} eventName name of the event you want to bind to
* @param {Function|undefined} callback callback that you want called upon the event occurring
*/
bind: function (eventName, callback) {
this.baseChannel.bind(eventName, function (data) {
callback(data);
$rootScope.$digest();
});
},
/**
* Binds to all of the channel events.
*
* @param {Function|undefined} callback callback that you want called upon the event occurring
*/
bind_all: function (callback) {
this.baseChannel.bind_all(function (eventName, data) {
callback(eventName, data);
$rootScope.$digest();
});
},
/**
* Triggers a client event.
* {@link https://pusher.com/docs/client_api_guide/client_events#trigger-events}
*
* @param {String} channelName name of the channel
* @param {String} eventName name of the event
* @param {Object} obj object that you wish to pass along with your client event
* @returns {}
*/
trigger: function (eventName, obj) {
checkPresenceChannel(this.name);
if (eventName.indexOf('client-') == -1) { throw new Error('Event name requires \'client-\' prefix'); }
return this.baseChannel.trigger(eventName, obj);
},
/**
* Asserts that the $channel object is being initialised with valid baseChannel.
* Throws an error if baseChannel is invalid.
*
* @param {Object} baseChannel channel object from base pusher channel object
*/
_assertValidChannel: function (baseChannel) {
if (!angular.isObject(baseChannel) ||
typeof(baseChannel.name) !== 'string') {
throw new Error('Invalid Pusher channel object');
}
}
}
return $channel;
}
])
.factory('$members', ['$rootScope', '$q',
function ($rootScope, $q) {
function $members (baseMembers, baseChannel) {
if (!(this instanceof $members)) {
return new $members(baseMembers, baseChannel);
}
var self = this;
this._assertValidMembers(baseMembers);
this.baseMembers = baseMembers;
this.baseChannel = baseChannel;
this.me = {};
this.count = 0;
this.members = {};
baseChannel.bind('pusher:subscription_succeeded', function (members) {
self.me = members.me;
self.count = members.count;
self.members = members.members;
$rootScope.$digest();
});
baseChannel.bind('pusher:member_added', function (member) {
self.count++;
if (member.info) {
self.members[member.id.toString()] = member.info;
} else {
self.members[member.id.toString()] = null;
}
$rootScope.$digest();
});
baseChannel.bind('pusher:member_removed', function (member) {
self.count--;
delete self.members[member.id.toString()];
$rootScope.$digest();
});
}
$members.prototype = {
/**
* Returns member's info for given id. Resulting object containts two fields - id and info.
*
* @param {Number} id user's id
* @return {Object} member's info or null
*/
get: function (id) {
return this.baseMembers.get(id);
},
/**
* Calls back for each member in unspecified order.
*
* @param {Function} callback callback function
*/
each: function (callback) {
this.baseMembers.each(function (member) {
callback(member);
$rootScope.$digest();
});
},
/**
* Asserts that the $members object is being initialised with valid baseMembers.
* Throws an error if baseMembers is invalid.
*
* @param {Object} baseMembers members object from base pusher channel object
*/
_assertValidMembers: function (baseMembers) {
if (!angular.isObject(baseMembers) ||
typeof(baseMembers.me) !== 'object') {
throw new Error('Invalid Pusher channel members object');
}
}
}
return $members;
}
])
.factory('$connection', ['$rootScope', '$q',
function ($rootScope, $q) {
function $connection (baseConnection, baseClient) {
if (!(this instanceof $connection)) {
return new $connection(baseConnection, baseClient);
}
var self = this;
this._assertValidConnection(baseConnection);
this.baseConnection = baseConnection;
this.baseClient = baseClient;
}
$connection.prototype = {
/**
* Binds to the given event name on the connection.
*
* @param {String} eventName name of the event you want to bind to
* @param {Function|undefined} callback callback that you want called upon the event occurring
*/
bind: function (eventName, callback) {
this.baseConnection.bind(eventName, function (data) {
callback(data);
$rootScope.$digest();
});
},
/**
* Binds to all of the global connection events.
*
* @param {Function|undefined} callback callback that you want called upon the event occurring
*/
bind_all: function (callback) {
this.baseConnection.bind_all(function (eventName, data) {
callback(eventName, data);
$rootScope.$digest();
});
},
/**
* Asserts that the $connection object is being initialised with valid baseConnection.
* Throws an error if baseConnection is invalid.
*
* @param {Object} baseConnection connection object from base pusher object
*/
_assertValidConnection: function (baseConnection) {
if (!angular.isObject(baseConnection)) {
throw new Error('Invalid Pusher connection object');
}
}
}
return $connection;
}
])
|
'use strict';
var util = require('util');
var EventEmitter = require('events').EventEmitter;
var hasher = require('./hasher');
var User = require('./model/user');
var Item = require('./model/item');
var Category = require('./model/category');
var JOURNAL_INTERVAL = 1000;
var EVENT_BUYNOW = 'buynow';
var API_CHANGE_BUYNOW = 'now';
var Client = function (options) {
EventEmitter.call(this);
options = options || {};
this._soapClient = options.soapClient;
this._key = options.key;
this._login = options.login;
this._countryId = options.countryId;
if (options.password) {
this._passwordHash = hasher.generatePasswordHash(options.password);
} else {
this._passwordHash = options.passwordHash;
}
var sessionHandle = null;
var self = this;
this._loginUser = function (callback) {
if (sessionHandle) {
callback(null, {
sessionHandlePart: sessionHandle
});
} else {
self._soapClient.doQuerySysStatus({
'sysvar': 3,
'countryId': self._countryId,
'webapiKey': self._key
}, function (err, result) {
if (!err) {
self._soapClient.doLoginEnc({
'userLogin': self._login,
'userHashPassword': self._passwordHash,
'countryCode': self._countryId,
'webapiKey': self._key,
'localVersion': result.verKey
}, function (err, result) {
sessionHandle = result.sessionHandlePart;
callback(err, result);
});
}
});
}
};
var oldestRowId = null;
this.on('newListener', function (event) {
if (event === EVENT_BUYNOW) {
setInterval(function () {
self._loginUser(function (err, result) {
var callArgs = {};
if (oldestRowId) {
callArgs = {
sessionHandle: result.sessionHandlePart,
startingPoint: parseFloat(oldestRowId),
infoType: 1
};
} else {
callArgs = {
sessionHandle: result.sessionHandlePart,
infoType: 1
};
}
self._soapClient.doGetSiteJournal(callArgs, function (err, result) {
if (!err) {
for (var i = 0; i < result.siteJournalArray.length; i += 1) {
result.siteJournalArray[i].item.forEach(emitEvent);
}
}
});
function emitEvent(item) {
if (item.changeType === API_CHANGE_BUYNOW) {
self.emit(event, item.itemId);
}
oldestRowId = item.rowId;
}
});
}, JOURNAL_INTERVAL);
}
});
};
util.inherits(Client, EventEmitter);
Client.prototype.getUser = function (userId, callback) {
this._soapClient.doShowUser({
'webapiKey': this._key,
'countryId': this._countryId,
'userId': userId
}, function (err, result) {
if (err) {
callback(err);
} else {
callback(null, new User(result));
}
});
};
Client.prototype.getItem = function (itemId, callback) {
var self = this;
this._loginUser(function (err, result) {
self._soapClient.doShowItemInfoExt({
sessionHandle: result.sessionHandlePart,
itemId: itemId,
getImageUrl: 1
}, function (err, result) {
if (err) {
callback(err);
} else {
callback(null, new Item(result, self));
}
});
});
};
Client.prototype.getCategory = function (itemId, callback) {
var self = this;
this._loginUser(function (err, result) {
self._soapClient.doGetCategoryPath({
sessionId: result.sessionHandlePart,
categoryId: itemId
}, function (err, result) {
if (err) {
callback(err);
} else {
var categories = result.categoryPath[0].item.length;
callback(null, new Category(result.categoryPath[0].item[categories - 1], self));
}
});
});
};
module.exports = Client;
|
/**
* Created by yakuncyk on 16/1/24.
*/
const net = require('net');
process.on('message', function (m, handle) {
start(handle);
});
var buf = 'hello nodejs';
var res = ['HTTP/1.1 200 ok', 'content-length:' + buf.length].join('\r\n') + '\r\n\r\n' + buf;
function start(server) {
server.listen();
server.onconnection = function(err,handle) {
console.log('got a connection on worker, pid = %d', process.pid);
var socket = new net.Socket({
handle: handle
});
socket.readable = socket.writable = true;
socket.end(res);
}
}
|
import { Registry } from 'container';
import factory from 'container/tests/test-helpers/factory';
import isEnabled from 'ember-metal/features';
QUnit.module('Registry');
QUnit.test('A registered factory is returned from resolve', function() {
var registry = new Registry();
var PostController = factory();
registry.register('controller:post', PostController);
var PostControllerFactory = registry.resolve('controller:post');
ok(PostControllerFactory, 'factory is returned');
ok(PostControllerFactory.create() instanceof PostController, 'The return of factory.create is an instance of PostController');
});
QUnit.test('The registered factory returned from resolve is the same factory each time', function() {
var registry = new Registry();
var PostController = factory();
registry.register('controller:post', PostController);
deepEqual(registry.resolve('controller:post'), registry.resolve('controller:post'), 'The return of resolve is always the same');
});
QUnit.test('The registered value returned from resolve is the same value each time even if the value is falsy', function() {
let registry = new Registry();
registry.register('falsy:value', null, { instantiate: false });
strictEqual(registry.resolve('falsy:value'), registry.resolve('falsy:value'), 'The return of resolve is always the same');
});
QUnit.test('The value returned from resolver is the same value as the original value even if the value is falsy', function() {
let resolver = {
resolve(fullName) {
if (fullName === 'falsy:value') {
return null;
}
}
};
let registry = new Registry({ resolver });
strictEqual(registry.resolve('falsy:value'), null);
});
QUnit.test('A registered factory returns true for `has` if an item is registered', function() {
var registry = new Registry();
var PostController = factory();
registry.register('controller:post', PostController);
equal(registry.has('controller:post'), true, 'The `has` method returned true for registered factories');
equal(registry.has('controller:posts'), false, 'The `has` method returned false for unregistered factories');
});
QUnit.test('Throw exception when trying to inject `type:thing` on all type(s)', function() {
var registry = new Registry();
var PostController = factory();
registry.register('controller:post', PostController);
throws(function() {
registry.typeInjection('controller', 'injected', 'controller:post');
}, /Cannot inject a `controller:post` on other controller\(s\)\./);
});
QUnit.test('The registry can take a hook to resolve factories lazily', function() {
let PostController = factory();
let resolver = {
resolve(fullName) {
if (fullName === 'controller:post') {
return PostController;
}
}
};
let registry = new Registry({ resolver });
strictEqual(registry.resolve('controller:post'), PostController, 'The correct factory was provided');
});
QUnit.test('The registry respects the resolver hook for `has`', function() {
let PostController = factory();
let resolver = {
resolve(fullName) {
if (fullName === 'controller:post') {
return PostController;
}
}
};
let registry = new Registry({ resolver });
ok(registry.has('controller:post'), 'the `has` method uses the resolver hook');
});
QUnit.test('The registry normalizes names when resolving', function() {
var registry = new Registry();
var PostController = factory();
registry.normalizeFullName = function(fullName) {
return 'controller:post';
};
registry.register('controller:post', PostController);
var type = registry.resolve('controller:normalized');
strictEqual(type, PostController, 'Normalizes the name when resolving');
});
QUnit.test('The registry normalizes names when checking if the factory is registered', function() {
var registry = new Registry();
var PostController = factory();
registry.normalizeFullName = function(fullName) {
return fullName === 'controller:normalized' ? 'controller:post' : fullName;
};
registry.register('controller:post', PostController);
var isPresent = registry.has('controller:normalized');
equal(isPresent, true, 'Normalizes the name when checking if the factory or instance is present');
});
QUnit.test('validateFullName throws an error if name is incorrect', function() {
expect(2);
var registry = new Registry();
var PostController = factory();
registry.normalize = function(fullName) {
return 'controller:post';
};
registry.register('controller:post', PostController);
throws(function() {
registry.validateFullName('post');
}, /TypeError: Invalid Fullname, expected: `type:name` got: post/);
throws(function() {
registry.validateFullName('route:http://foo.bar.com/baz');
}, /TypeError: Invalid Fullname, expected: `type:name` got: route:http:\/\/foo.bar.com\/baz/);
});
QUnit.test('The registry normalizes names when injecting', function() {
var registry = new Registry();
var PostController = factory();
var user = { name: 'Stef' };
registry.normalize = function(fullName) {
return 'controller:post';
};
registry.register('controller:post', PostController);
registry.register('user:post', user, { instantiate: false });
registry.injection('controller:post', 'user', 'controller:normalized');
deepEqual(registry.resolve('controller:post'), user, 'Normalizes the name when injecting');
});
QUnit.test('cannot register an `undefined` factory', function() {
var registry = new Registry();
throws(function() {
registry.register('controller:apple', undefined);
}, '');
});
QUnit.test('can re-register a factory', function() {
var registry = new Registry();
var FirstApple = factory('first');
var SecondApple = factory('second');
registry.register('controller:apple', FirstApple);
registry.register('controller:apple', SecondApple);
ok(registry.resolve('controller:apple').create() instanceof SecondApple);
});
QUnit.test('cannot re-register a factory if it has been resolved', function() {
var registry = new Registry();
var FirstApple = factory('first');
var SecondApple = factory('second');
registry.register('controller:apple', FirstApple);
strictEqual(registry.resolve('controller:apple'), FirstApple);
throws(function() {
registry.register('controller:apple', SecondApple);
}, /Cannot re-register: `controller:apple`, as it has already been resolved\./);
strictEqual(registry.resolve('controller:apple'), FirstApple);
});
QUnit.test('registry.has should not accidentally cause injections on that factory to be run. (Mitigate merely on observing)', function() {
expect(1);
var registry = new Registry();
var FirstApple = factory('first');
var SecondApple = factory('second');
SecondApple.extend = function(a, b, c) {
ok(false, 'should not extend or touch the injected model, merely to inspect existence of another');
};
registry.register('controller:apple', FirstApple);
registry.register('controller:second-apple', SecondApple);
registry.injection('controller:apple', 'badApple', 'controller:second-apple');
ok(registry.has('controller:apple'));
});
QUnit.test('registry.has should not error for invalid fullNames)', function() {
expect(1);
var registry = new Registry();
ok(!registry.has('foo:bar:baz'));
});
QUnit.test('once resolved, always return the same result', function() {
expect(1);
var registry = new Registry();
registry.resolver = {
resolve() {
return 'bar';
}
};
var Bar = registry.resolve('models:bar');
registry.resolver = {
resolve() {
return 'not bar';
}
};
equal(registry.resolve('models:bar'), Bar);
});
QUnit.test('factory resolves are cached', function() {
var registry = new Registry();
var PostController = factory();
var resolveWasCalled = [];
registry.resolver = {
resolve(fullName) {
resolveWasCalled.push(fullName);
return PostController;
}
};
deepEqual(resolveWasCalled, []);
registry.resolve('controller:post');
deepEqual(resolveWasCalled, ['controller:post']);
registry.resolve('controller:post');
deepEqual(resolveWasCalled, ['controller:post']);
});
QUnit.test('factory for non extendables (MODEL) resolves are cached', function() {
var registry = new Registry();
var PostController = factory();
var resolveWasCalled = [];
registry.resolver = {
resolve(fullName) {
resolveWasCalled.push(fullName);
return PostController;
}
};
deepEqual(resolveWasCalled, []);
registry.resolve('model:post');
deepEqual(resolveWasCalled, ['model:post']);
registry.resolve('model:post');
deepEqual(resolveWasCalled, ['model:post']);
});
QUnit.test('factory for non extendables resolves are cached', function() {
var registry = new Registry();
var PostController = {};
var resolveWasCalled = [];
registry.resolver = {
resolve(fullName) {
resolveWasCalled.push(fullName);
return PostController;
}
};
deepEqual(resolveWasCalled, []);
registry.resolve('foo:post');
deepEqual(resolveWasCalled, ['foo:post']);
registry.resolve('foo:post');
deepEqual(resolveWasCalled, ['foo:post']);
});
QUnit.test('registry.container creates a container', function() {
var registry = new Registry();
var PostController = factory();
registry.register('controller:post', PostController);
var container = registry.container();
var postController = container.lookup('controller:post');
ok(postController instanceof PostController, 'The lookup is an instance of the registered factory');
});
QUnit.test('`describe` will be handled by the resolver, then by the fallback registry, if available', function() {
let fallback = {
describe(fullName) {
return `${fullName}-fallback`;
}
};
let resolver = {
lookupDescription(fullName) {
return `${fullName}-resolver`;
}
};
let registry = new Registry({ fallback, resolver });
equal(registry.describe('controller:post'), 'controller:post-resolver', '`describe` handled by the resolver first.');
registry.resolver = null;
equal(registry.describe('controller:post'), 'controller:post-fallback', '`describe` handled by fallback registry next.');
registry.fallback = null;
equal(registry.describe('controller:post'), 'controller:post', '`describe` by default returns argument.');
});
QUnit.test('`normalizeFullName` will be handled by the resolver, then by the fallback registry, if available', function() {
let fallback = {
normalizeFullName(fullName) {
return `${fullName}-fallback`;
}
};
let resolver = {
normalize(fullName) {
return `${fullName}-resolver`;
}
};
let registry = new Registry({ fallback, resolver });
equal(registry.normalizeFullName('controller:post'), 'controller:post-resolver', '`normalizeFullName` handled by the resolver first.');
registry.resolver = null;
equal(registry.normalizeFullName('controller:post'), 'controller:post-fallback', '`normalizeFullName` handled by fallback registry next.');
registry.fallback = null;
equal(registry.normalizeFullName('controller:post'), 'controller:post', '`normalizeFullName` by default returns argument.');
});
QUnit.test('`makeToString` will be handled by the resolver, then by the fallback registry, if available', function() {
let fallback = {
makeToString(fullName) {
return `${fullName}-fallback`;
}
};
let resolver = {
makeToString(fullName) {
return `${fullName}-resolver`;
}
};
let registry = new Registry({ fallback, resolver });
equal(registry.makeToString('controller:post'), 'controller:post-resolver', '`makeToString` handled by the resolver first.');
registry.resolver = null;
equal(registry.makeToString('controller:post'), 'controller:post-fallback', '`makeToString` handled by fallback registry next.');
registry.fallback = null;
equal(registry.makeToString('controller:post'), 'controller:post', '`makeToString` by default returns argument.');
});
QUnit.test('`resolve` can be handled by a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
var PostController = factory();
fallback.register('controller:post', PostController);
var PostControllerFactory = registry.resolve('controller:post');
ok(PostControllerFactory, 'factory is returned');
ok(PostControllerFactory.create() instanceof PostController, 'The return of factory.create is an instance of PostController');
});
QUnit.test('`has` can be handled by a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
var PostController = factory();
fallback.register('controller:post', PostController);
equal(registry.has('controller:post'), true, 'Fallback registry is checked for registration');
});
QUnit.test('`getInjections` includes injections from a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
equal(registry.getInjections('model:user').length, 0, 'No injections in the primary registry');
fallback.injection('model:user', 'post', 'model:post');
equal(registry.getInjections('model:user').length, 1, 'Injections from the fallback registry are merged');
});
QUnit.test('`getTypeInjections` includes type injections from a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
equal(registry.getTypeInjections('model').length, 0, 'No injections in the primary registry');
fallback.injection('model', 'source', 'source:main');
equal(registry.getTypeInjections('model').length, 1, 'Injections from the fallback registry are merged');
});
QUnit.test('`getFactoryInjections` includes factory injections from a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
equal(registry.getFactoryInjections('model:user').length, 0, 'No factory injections in the primary registry');
fallback.factoryInjection('model:user', 'store', 'store:main');
equal(registry.getFactoryInjections('model:user').length, 1, 'Factory injections from the fallback registry are merged');
});
QUnit.test('`getFactoryTypeInjections` includes factory type injections from a fallback registry', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
equal(registry.getFactoryTypeInjections('model').length, 0, 'No factory type injections in the primary registry');
fallback.factoryInjection('model', 'store', 'store:main');
equal(registry.getFactoryTypeInjections('model').length, 1, 'Factory type injections from the fallback registry are merged');
});
QUnit.test('`knownForType` contains keys for each item of a given type', function() {
let registry = new Registry();
registry.register('foo:bar-baz', 'baz');
registry.register('foo:qux-fez', 'fez');
let found = registry.knownForType('foo');
deepEqual(found, {
'foo:bar-baz': true,
'foo:qux-fez': true
});
});
QUnit.test('`knownForType` includes fallback registry results', function() {
var fallback = new Registry();
var registry = new Registry({ fallback: fallback });
registry.register('foo:bar-baz', 'baz');
registry.register('foo:qux-fez', 'fez');
fallback.register('foo:zurp-zorp', 'zorp');
let found = registry.knownForType('foo');
deepEqual(found, {
'foo:bar-baz': true,
'foo:qux-fez': true,
'foo:zurp-zorp': true
});
});
QUnit.test('`knownForType` is called on the resolver if present', function() {
expect(3);
let resolver = {
knownForType(type) {
ok(true, 'knownForType called on the resolver');
equal(type, 'foo', 'the type was passed through');
return { 'foo:yorp': true };
}
};
var registry = new Registry({
resolver
});
registry.register('foo:bar-baz', 'baz');
let found = registry.knownForType('foo');
deepEqual(found, {
'foo:yorp': true,
'foo:bar-baz': true
});
});
QUnit.test('A registry can be created with a deprecated `resolver` function instead of an object', function() {
expect(2);
let registry;
expectDeprecation(function() {
registry = new Registry({
resolver(fullName) {
return `${fullName}-resolved`;
}
});
}, 'Passing a `resolver` function into a Registry is deprecated. Please pass in a Resolver object with a `resolve` method.');
equal(registry.resolve('foo:bar'), 'foo:bar-resolved', '`resolve` still calls the deprecated function');
});
if (isEnabled('ember-htmlbars-local-lookup')) {
// jscs:disable validateIndentation
QUnit.test('resolver.expandLocalLookup is not required', function(assert) {
assert.expect(1);
var registry = new Registry({
resolver: { }
});
let result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, null);
});
QUnit.test('expandLocalLookup is called on the resolver if present', function(assert) {
assert.expect(4);
let resolver = {
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through');
assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through');
return 'foo:qux/bar';
}
};
var registry = new Registry({
resolver
});
let result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar');
});
QUnit.test('`expandLocalLookup` is handled by the resolver, then by the fallback registry, if available', function(assert) {
assert.expect(9);
let fallbackResolver = {
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the fallback resolver');
assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through');
assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through');
return 'foo:qux/bar-fallback';
}
};
let resolver = {
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through');
assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through');
return 'foo:qux/bar-resolver';
}
};
let fallbackRegistry = new Registry({
resolver: fallbackResolver
});
let registry = new Registry({
fallback: fallbackRegistry,
resolver
});
let result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar-resolver', 'handled by the resolver');
registry.resolver = null;
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar-fallback', 'handled by the fallback registry');
registry.fallback = null;
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, null, 'null is returned by default when no resolver or fallback registry is present');
});
QUnit.test('resolver.expandLocalLookup result is cached', function(assert) {
assert.expect(3);
let result;
let resolver = {
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
return 'foo:qux/bar';
}
};
var registry = new Registry({
resolver
});
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar');
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar');
});
QUnit.test('resolver.expandLocalLookup cache is busted when any unregister is called', function(assert) {
assert.expect(4);
let result;
let resolver = {
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
return 'foo:qux/bar';
}
};
var registry = new Registry({
resolver
});
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar');
registry.unregister('foo:bar');
result = registry.expandLocalLookup('foo:bar', {
source: 'baz:qux'
});
assert.equal(result, 'foo:qux/bar');
});
QUnit.test('resolve calls expandLocallookup when it receives options.source', function(assert) {
assert.expect(3);
let resolver = {
resolve() { },
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through');
assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through');
return 'foo:qux/bar';
}
};
var registry = new Registry({
resolver
});
registry.resolve('foo:bar', {
source: 'baz:qux'
});
});
QUnit.test('has uses expandLocalLookup', function(assert) {
assert.expect(5);
let resolvedFullNames = [];
let result;
let resolver = {
resolve(name) {
resolvedFullNames.push(name);
return 'yippie!';
},
expandLocalLookup(targetFullName, sourceFullName) {
assert.ok(true, 'expandLocalLookup is called on the resolver');
if (targetFullName === 'foo:bar') {
return 'foo:qux/bar';
} else {
return null;
}
}
};
var registry = new Registry({
resolver
});
result = registry.has('foo:bar', {
source: 'baz:qux'
});
assert.ok(result, 'found foo:bar/qux');
result = registry.has('foo:baz', {
source: 'baz:qux'
});
assert.ok(!result, 'foo:baz/qux not found');
assert.deepEqual(['foo:qux/bar'], resolvedFullNames);
});
}
|
// var express = require('express');
// var app = express();
// var bodyParser = require('body-parser');
// app.use(bodyParser.urlencoded({extended: false}));
var CODES = {
HELP: "hlp",
REGISTER: "reg",
REPLY: "rep"
};
function prepareSMS(msg){
var sms = msg.sms;
if (typeof sms === 'string') {
console.log('sms is string');
}
else{
console.log('type:', typeof sms);
console.log('sms:', sms);
}
return sms.trim();
}
function getCode(sms){
//sms.substr(0,)
}
// curl -v -XPOST -H "Content-type: application/json" -d '{"sms": "from: +381 64 2830738; body:reg. Sinisa Rudan. poet"}' 'http://127.0.0.1:8001/smsapi'
exports.create = function(req, res){
console.log("[modules/smsapi.js:create] req: %s", req);
console.log("[modules/smsapi.js:create] req.body: %s", JSON.stringify(req.body));
console.log('req.body:',req.body);
var sms = prepareSMS(req.body);
res.send("<Response><Message>Hello from the CoLaboArthon - SMS Service!</Message></Response>");
}
// app.post("/message", function (req, response) {
// console.log('req:',req);
// console.log('response:',response);
// console.log(req.body);
// response.send("<Response><Message>Hello from the CoLaboArthon - SMS Service!</Message></Response>")
// });
// curl -v -H "Content-Type: application/json" -X GET http://127.0.0.1:8001/smsapi
exports.index = function(req, res){
console.log("[modules/smsapi.js:index] req: %s", JSON.stringify(req));
res.send('<HTML><body>HELLO from SMSAPI</body></HTML>');
}
// app.get("/", function (req, response) {
// console.log('req:',req);
// console.log('response:',response);
// response.sendFile(__dirname + '/views/index.html');
// });
//
// var listener = app.listen(process.env.PORT, function () {
// console.log('Your app is listening on port ' + listener.address().port);
// });
|
function navigate(url) {
chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
chrome.tabs.update(tabs[0].id, {url: url});
});
}
chrome.omnibox.onInputEntered.addListener(function(text) {
navigate('http://gomarks.herokuapp.com/' + text);
});
function search(query, callback) {
var url = "http://gomarks.herokuapp.com/links/suggest?q=" + query;
var req = new XMLHttpRequest();
req.open("GET", url, true);
req.onreadystatechange = function() {
if (req.readyState == 4) {
var data = JSON.parse(req.responseText);
callback(data);
}
}
req.send(null);
return req;
}
chrome.omnibox.onInputChanged.addListener(
function(text, suggest) {
search(text, function(data) {
var suggestions = [];
for (var item in data) {
suggestions.push({
content: data[item],
description: data[item],
});
}
suggest(suggestions);
chrome.omnibox.setDefaultSuggestion({
description: text
});
});
});
|
import {App} from './app';
export class NoSelection{
static inject(){ return [App]; }
constructor(app){
this.app = app;
}
activate(){
this.app.selectedId = null;
}
}
|
import Notification from "./Notification";
export default Notification;
|
/**
*
* SelectComponents
*
*/
import React from 'react';
import PropTypes from 'prop-types';
import { MultiSelectNested } from '@strapi/design-system/Select';
import { useIntl } from 'react-intl';
import useDataManager from '../../hooks/useDataManager';
import findAttribute from '../../utils/findAttribute';
import { getTrad } from '../../utils';
const SelectComponents = ({ dynamicZoneTarget, intlLabel, name, onChange, value }) => {
const { formatMessage } = useIntl();
const { componentsGroupedByCategory, modifiedData } = useDataManager();
const dzSchema =
findAttribute(modifiedData.contentType.schema.attributes, dynamicZoneTarget) || {};
const alreadyUsedComponents = dzSchema.components || [];
const filteredComponentsGroupedByCategory = Object.keys(componentsGroupedByCategory).reduce(
(acc, current) => {
const filteredComponents = componentsGroupedByCategory[current].filter(({ uid }) => {
return !alreadyUsedComponents.includes(uid);
});
if (filteredComponents.length > 0) {
acc[current] = filteredComponents;
}
return acc;
},
{}
);
const options = Object.entries(filteredComponentsGroupedByCategory).reduce((acc, current) => {
const [categoryName, components] = current;
const section = {
label: categoryName,
children: components.map(({ uid, schema: { displayName } }) => {
return { label: displayName, value: uid };
}),
};
acc.push(section);
return acc;
}, []);
const displayedValue = formatMessage(
{
id: getTrad('components.SelectComponents.displayed-value'),
defaultMessage:
'{number, plural, =0 {# components} one {# component} other {# components}} selected',
},
{ number: value.length }
);
return (
<MultiSelectNested
id="select1"
label={formatMessage(intlLabel)}
customizeContent={() => displayedValue}
name={name}
onChange={values => {
onChange({ target: { name, value: values, type: 'select-components' } });
}}
options={options}
value={value || []}
/>
);
};
SelectComponents.propTypes = {
intlLabel: PropTypes.shape({
id: PropTypes.string.isRequired,
defaultMessage: PropTypes.string.isRequired,
values: PropTypes.object,
}).isRequired,
dynamicZoneTarget: PropTypes.string.isRequired,
name: PropTypes.string.isRequired,
onChange: PropTypes.func.isRequired,
value: PropTypes.array.isRequired,
};
export default SelectComponents;
|
(function(){
Template.__define__("addRewards", (function() {
var self = this;
var template = this;
return [ HTML.Raw("<!--Modal launched when Edit button below clicked -->\n "), HTML.DIV({
"class": "modal fade",
id: "addRewardsModal"
}, "\n ", HTML.DIV({
"class": "modal-dialog"
}, "\n ", HTML.DIV({
"class": "modal-content"
}, HTML.Raw('\n <div class="modal-header">\n <button type="button" class="close" data-dismiss="modal" aria-hidden="true">\n ×</button>\n <h4 class="modal-title text-center">Edit Rewards</h4>\n </div>\n '), HTML.DIV({
"class": "modal-body"
}, "\n ", Spacebars.TemplateWith(function() {
return {
collection: Spacebars.call("Rewards"),
id: Spacebars.call("insertRewardForm"),
type: Spacebars.call("insert")
};
}, UI.block(function() {
var self = this;
return Spacebars.include(self.lookupTemplate("autoForm"), UI.block(function() {
var self = this;
return [ "\n ", HTML.FIELDSET("\n ", HTML.LEGEND("Update Reward"), "\n ", Spacebars.TemplateWith(function() {
return {
name: Spacebars.call("name")
};
}, UI.block(function() {
var self = this;
return Spacebars.include(self.lookupTemplate("afQuickField"));
})), "\n ", Spacebars.TemplateWith(function() {
return {
name: Spacebars.call("description")
};
}, UI.block(function() {
var self = this;
return Spacebars.include(self.lookupTemplate("afQuickField"));
})), "\n ", Spacebars.TemplateWith(function() {
return {
name: Spacebars.call("price")
};
}, UI.block(function() {
var self = this;
return Spacebars.include(self.lookupTemplate("afQuickField"));
})), "\n "), "\n ", HTML.BUTTON({
type: "submit",
"class": "btn btn-default",
id: "submit"
}, "Submit"), "\n " ];
}));
})), "\n "), HTML.Raw('\n <div class="modal-footer">\n <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>\n </div>\n ')), HTML.Raw("<!-- /.modal-content -->\n ")), HTML.Raw("<!-- /.modal-dialog -->\n ")), HTML.Raw("<!-- /.modal -->\n "), Spacebars.include(self.lookupTemplate("listRewards")), HTML.Raw('\n <div class="row text-center">\n <button type="button" class="btn btn-lg btn-default text-center" id="addEvent" data-toggle="modal" data-target="#addRewardsModal">Add Reward</button>\n </div>') ];
}));
})();
|
//Simple fibonacci
var F = function F(n) {
return n == 0 ? 1 : n * F(n - 1);
};
console.log(F(5)) //120
//Reduce inline `F` using JavaScript callee
var F = function F(n) {
return n == 0 ? 1 : n * arguments.callee(n - 1)
};
console.log(F(5)) //120
//Reduce inline `F` using lambda
var F = function F(f) {
return function (n) {
return n == 0 ? 1 : n * f(f)(n - 1)
//first call f will generate a function with `n` as args, then eval
}
}
console.log(F(F)(5)) //120
//Reduce all using Y combinator, which meas replace first `F` with lambda
console.log(
function (f) {
return function (n) {
return n == 0 ? 1 : n * f(f)(n - 1)
}
}(function (f) {
return function (n) {
return n == 0 ? 1 : n * f(f)(n - 1)
}
})(5) //120
)
//So now we have a pure function with no name -> pure lambda
//We can conclude that how to generate a recursion lambda :
function lambda(f) {
return function (args) {
//return what your recursion body will return
}(function (f) {
return function (args) {
//return what your recursion body will return
}
})
}('args')
//And finally we build a `Y-combinator`
var Y = require("./y")
var fibonacci = Y(function(f) {
return function(n) {
return n == 0 ? 1 : n * f(n - 1);
}
})
console.log(fibonacci(5))
|
'use strict';
var _ = require('lodash'); /* jshint ignore:line */
var CredentialList = require('./v2/credential').CredentialList;
var ServiceList = require('./v2/service').ServiceList;
var Version = require('../../base/Version'); /* jshint ignore:line */
/* jshint ignore:start */
/**
* Initialize the V2 version of Chat
*
* @constructor Twilio.Chat.V2
*
* @property {Twilio.Chat.V2.CredentialList} credentials - credentials resource
* @property {Twilio.Chat.V2.ServiceList} services - services resource
*
* @param {Twilio.Chat} domain - The twilio domain
*/
/* jshint ignore:end */
function V2(domain) {
Version.prototype.constructor.call(this, domain, 'v2');
// Resources
this._credentials = undefined;
this._services = undefined;
}
_.extend(V2.prototype, Version.prototype);
V2.prototype.constructor = V2;
Object.defineProperty(V2.prototype,
'credentials', {
get: function() {
this._credentials = this._credentials || new CredentialList(this);
return this._credentials;
}
});
Object.defineProperty(V2.prototype,
'services', {
get: function() {
this._services = this._services || new ServiceList(this);
return this._services;
}
});
module.exports = V2;
|
// tokens.js
// 2009-05-17
// (c) 2006 Douglas Crockford
// Produce an array of simple token objects from a string.
// A simple token object contains these members:
// type: 'name', 'string', 'number', 'operator'
// value: string or number value of the token
// from: index of first character of the token
// to: index of the last character + 1
// Comments of the // type are ignored.
// Operators are by default single characters. Multicharacter
// operators can be made by supplying a string of prefix and
// suffix characters.
// characters. For example,
// '<>+-&', '=>&:'
// will match any of these:
// <= >> >>> <> >= +: -: &: &&: &&
String.prototype.tokens = function (prefix, suffix) {
var c; // The current character.
var from; // The index of the start of the token.
var i = 0; // The index of the current character.
var length = this.length;
var n; // The number value.
var q; // The quote character.
var str; // The string value.
var result = []; // An array to hold the results.
var prereg = true;
var make = function (type, value) {
// Make a token object.
//prereg = i &&
// (('(,=:[!&|?{};'.indexOf(i.charAt(i.length - 1)) >= 0) ||
// i === 'return')
//print(type+":"+value+"-")
prereg = (type == 'operator' || type === 'name') &&
(value === 'return' || ('(,=:[!&|?{};'.indexOf(value.charAt(value.length - 1)) >= 0 ) )
//print(type+" : "+value+" - "+prereg)
return {
type: type,
value: value,
from: from,
to: i
};
};
var has = function(thIs, before){
var j = i+1;
for (;;) {
c = this.charAt(j);
if(c === thIs){
return true;
}
//print("|"+c+"|"+(c=="\n" || c=="\r"));
if (before.test(c) || c === '') {
return false;
}
j += 1;
}
}
// Begin tokenization. If the source string is empty, return nothing.
if (!this) {
return;
}
// If prefix and suffix strings are not provided, supply defaults.
if (typeof prefix !== 'string') {
prefix = '<>+-&';
}
if (typeof suffix !== 'string') {
suffix = '=>&:';
}
// Loop through this text, one character at a time.
c = this.charAt(i);
while (c) {
from = i;
//print(c);
// Ignore whitespace.
if (c <= ' ') {
i += 1;
c = this.charAt(i);
// name.
} else if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') {
str = c;
i += 1;
for (;;) {
c = this.charAt(i);
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c === '_') {
str += c;
i += 1;
} else {
break;
}
}
//print(str);
result.push(make('name', str));
// number.
// A number cannot start with a decimal point. It must start with a digit,
// possibly '0'.
} else if (c >= '0' && c <= '9') {
str = c;
i += 1;
// Look for more digits.
for (;;) {
c = this.charAt(i);
if (c < '0' || c > '9') {
break;
}
i += 1;
str += c;
}
// Look for a decimal fraction part.
if (c === '.') {
i += 1;
str += c;
for (;;) {
c = this.charAt(i);
if (c < '0' || c > '9') {
break;
}
i += 1;
str += c;
}
}
// Look for an exponent part.
if (c === 'e' || c === 'E') {
i += 1;
str += c;
c = this.charAt(i);
if (c === '-' || c === '+') {
i += 1;
str += c;
c = this.charAt(i);
}
if (c < '0' || c > '9') {
make('number', str).error("Bad exponent");
}
do {
i += 1;
str += c;
c = this.charAt(i);
} while (c >= '0' && c <= '9');
}
// Make sure the next character is not a letter.
if (c >= 'a' && c <= 'z') {
str += c;
i += 1;
print(this.substr(i-20,20))
print(this.substr(i,20))
make('number', str).error("Bad number");
}
// Convert the string value to a number. If it is finite, then it is a good
// token.
n = +str;
if (isFinite(n)) {
result.push(make('number', n));
} else {
make('number', str).error("Bad number");
}
// string
} else if (c === '\'' || c === '"') {
str = '';
q = c;
i += 1;
//print("----")
for (;;) {
c = this.charAt(i);
//print(this[i])
if (c < ' ') {
print(this.substr(i-20,20))
print(this.substr(i,20))
make('string', str).error(c === '\n' || c === '\r' || c === '' ?
"Unterminated string." :
"Control character in string.", make('', str));
}
// Look for the closing quote.
if (c === q) {
break;
}
// Look for escapement.
if (c === '\\') {
i += 1;
if (i >= length) {
make('string', str).error("Unterminated string");
}
c = this.charAt(i);
switch (c) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'u':
if (i >= length) {
make('string', str).error("Unterminated string");
}
c = parseInt(this.substr(i + 1, 4), 16);
if (!isFinite(c) || c < 0) {
make('string', str).error("Unterminated string");
}
c = String.fromCharCode(c);
i += 4;
break;
}
}
str += c;
i += 1;
}
i += 1;
//print("str = "+str)
result.push(make('string', str));
c = this.charAt(i);
// comment.
} else if (c === '/' && this.charAt(i + 1) === '*') {
i += 1;
for (;;) {
c = this.charAt(i);
if (c === '*' && this.charAt(i+1) == "/") {
i += 1;
i += 1;
break;
}
i += 1;
}
} else if (c === '/' && this.charAt(i + 1) === '/') {
i += 1;
for (;;) {
c = this.charAt(i);
if (c === '\n' || c === '\r' || c === '') {
break;
}
i += 1;
}
// regexp
} else if (c === '/' && has.call(this, "/", /[\n\r]/) && prereg) { // what about /2
//print('matcing regexp')
i += 1;
var str = c;
for (;;) {
c = this.charAt(i);
if(c === "\\"){ //skip over \
str += c;
i += 1;
//print("adding "+c)
c = this.charAt(i);
str += c;
//print("adding "+c)
i += 1;
c = this.charAt(i);
continue;
}
if (c === '/' ) {
str += c;
i += 1;
c = this.charAt(i);
while(/\w/.test(c)){ //get stuff after /a/m
str += c;
i += 1;
c = this.charAt(i);
}
result.push(make('regexp', str));
//print("regexp = "+str)
break;
}
str += c;
i += 1;
}
// combining
} else if (prefix.indexOf(c) >= 0) {
str = c;
i += 1;
while (i < length) {
c = this.charAt(i);
if (suffix.indexOf(c) < 0) {
break;
}
str += c;
i += 1;
}
result.push(make('operator', str));
// single-character operator
} else {
i += 1;
result.push(make('operator', c));
c = this.charAt(i);
}
}
return result;
};
|
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<React.Fragment><path d="M16.11 7l-.59-.65L14.28 5h-4.24L8.81 6.35l-.6.65H4v12h7v-1.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V19h7V7h-3.89zM14 12c0 1.1-.9 2-2 2s-2-.9-2-2V8c0-1.1.9-2 2-2s2 .9 2 2v4z" opacity=".3" /><path d="M12 6c-1.1 0-2 .9-2 2v4c0 1.1.9 2 2 2s2-.9 2-2V8c0-1.1-.9-2-2-2zm8-1h-3.17l-1.86-2H8.96L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-7v-1.09c2.83-.48 5-2.94 5-5.91h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6c0 2.97 2.17 5.43 5 5.91V19H4V7h4.21l.59-.65L10.04 5h4.24l1.24 1.35.59.65H20v12z" /></React.Fragment>
, 'PermCameraMicTwoTone');
|
$(function() {
$(".filter-item").click(function() {
$(ul.post-index > a.post-item-wrapper).addClass("post-category-hidden");
});
});
|
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z" />
, 'AccessAlarmOutlined');
|
import { Meteor } from 'meteor/meteor';
import { TAPi18n } from 'meteor/rocketchat:tap-i18n';
import { escapeRegExp } from '@rocket.chat/string-helpers';
import { callbacks } from '../../../../callbacks';
import { settings } from '../../../../settings';
/**
* This function returns a string ready to be shown in the notification
*
* @param {object} message the message to be parsed
*/
export function parseMessageTextPerUser(messageText, message, receiver) {
const lng = receiver.language || settings.get('Language') || 'en';
if (!message.msg && message.attachments && message.attachments[0]) {
return message.attachments[0].image_type ? TAPi18n.__('User_uploaded_image', { lng }) : TAPi18n.__('User_uploaded_file', { lng });
}
if (message.msg && message.t === 'e2e') {
return TAPi18n.__('Encrypted_message', { lng });
}
// perform processing required before sending message as notification such as markdown filtering
return callbacks.run('renderNotification', messageText);
}
/**
* Replaces @username with full name
*
* @param {string} message The message to replace
* @param {object[]} mentions Array of mentions used to make replacements
*
* @returns {string}
*/
export function replaceMentionedUsernamesWithFullNames(message, mentions) {
if (!mentions || !mentions.length) {
return message;
}
mentions.forEach((mention) => {
if (mention.name) {
message = message.replace(new RegExp(escapeRegExp(`@${ mention.username }`), 'g'), mention.name);
}
});
return message;
}
/**
* Checks if a message contains a user highlight
*
* @param {string} message
* @param {array|undefined} highlights
*
* @returns {boolean}
*/
export function messageContainsHighlight(message, highlights) {
if (! highlights || highlights.length === 0) { return false; }
return highlights.some(function(highlight) {
const regexp = new RegExp(escapeRegExp(highlight), 'i');
return regexp.test(message.msg);
});
}
export function callJoinRoom(userId, rid) {
return new Promise((resolve, reject) => {
Meteor.runAsUser(userId, () => Meteor.call('joinRoom', rid, (error, result) => {
if (error) {
return reject(error);
}
return resolve(result);
}));
});
}
|
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @generated SignedSource<<9fa35a6597a0a8ae3b51344d14969d5d>>
* @flow
* @lightSyntaxTransform
* @nogrep
*/
/* eslint-disable */
'use strict';
/*::
import type { ConcreteRequest } from 'relay-runtime';
export type ActorNameChangeInput = {|
clientMutationId?: ?string,
newName?: ?string,
|};
export type validateMutationTest2ChangeNameMutationVariables = {|
input: ActorNameChangeInput,
|};
export type validateMutationTest2ChangeNameMutationResponse = {|
+actorNameChange: ?{|
+actor: ?{|
+name: ?string,
|},
|},
|};
export type validateMutationTest2ChangeNameMutation = {|
variables: validateMutationTest2ChangeNameMutationVariables,
response: validateMutationTest2ChangeNameMutationResponse,
|};
*/
var node/*: ConcreteRequest*/ = (function(){
var v0 = [
{
"defaultValue": null,
"kind": "LocalArgument",
"name": "input"
}
],
v1 = [
{
"kind": "Variable",
"name": "input",
"variableName": "input"
}
],
v2 = {
"alias": null,
"args": null,
"kind": "ScalarField",
"name": "name",
"storageKey": null
};
return {
"fragment": {
"argumentDefinitions": (v0/*: any*/),
"kind": "Fragment",
"metadata": null,
"name": "validateMutationTest2ChangeNameMutation",
"selections": [
{
"alias": null,
"args": (v1/*: any*/),
"concreteType": "ActorNameChangePayload",
"kind": "LinkedField",
"name": "actorNameChange",
"plural": false,
"selections": [
{
"alias": null,
"args": null,
"concreteType": null,
"kind": "LinkedField",
"name": "actor",
"plural": false,
"selections": [
(v2/*: any*/)
],
"storageKey": null
}
],
"storageKey": null
}
],
"type": "Mutation",
"abstractKey": null
},
"kind": "Request",
"operation": {
"argumentDefinitions": (v0/*: any*/),
"kind": "Operation",
"name": "validateMutationTest2ChangeNameMutation",
"selections": [
{
"alias": null,
"args": (v1/*: any*/),
"concreteType": "ActorNameChangePayload",
"kind": "LinkedField",
"name": "actorNameChange",
"plural": false,
"selections": [
{
"alias": null,
"args": null,
"concreteType": null,
"kind": "LinkedField",
"name": "actor",
"plural": false,
"selections": [
{
"alias": null,
"args": null,
"kind": "ScalarField",
"name": "__typename",
"storageKey": null
},
(v2/*: any*/),
{
"alias": null,
"args": null,
"kind": "ScalarField",
"name": "id",
"storageKey": null
}
],
"storageKey": null
}
],
"storageKey": null
}
]
},
"params": {
"cacheID": "2d953f7584501927922c57165679b5e3",
"id": null,
"metadata": {},
"name": "validateMutationTest2ChangeNameMutation",
"operationKind": "mutation",
"text": "mutation validateMutationTest2ChangeNameMutation(\n $input: ActorNameChangeInput!\n) {\n actorNameChange(input: $input) {\n actor {\n __typename\n name\n id\n }\n }\n}\n"
}
};
})();
if (__DEV__) {
(node/*: any*/).hash = "b253eaee773f43048515e1ded4ee72aa";
}
module.exports = node;
|
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon( /*#__PURE__*/_jsx("path", {
d: "m14 9-1-2H7V5.72c.6-.34 1-.98 1-1.72 0-1.1-.9-2-2-2s-2 .9-2 2c0 .74.4 1.38 1 1.72V21h2v-4h5l1 2h7V9h-6zm4 8h-4l-1-2H7V9h5l1 2h5v6z"
}), 'EmojiFlagsOutlined');
|
import Head from '../../components/Head'
import Layout from '../../layout/page'
import Article from '../../components/Article'
import fetchPostShowPath from '../../libs/fetchPostShowPath'
import fetchPostShowData from '../../libs/fetchPostShowData'
const LANG = 'tw'
export const PostComponentFactory = lang => (props) => {
const { pageName, pageDesc, pageImage } = props
const { website_name, website_description, home_url, menu_items } = props
const { post_feature_image_url, post_date, post_title, post_content } = props
return (
<>
<Head {...{ pageName, pageDesc, pageImage }} />
<Layout {...{ lang, home_url, website_name, website_description, menu_items }}>
<Article
feature_image_url={post_feature_image_url}
date={post_date}
title={post_title}
content={post_content}
/>
</Layout>
</>
)
}
export const getStaticPathsFactory = lang => async () => {
const paths = await fetchPostShowPath({ lang })
return { paths, fallback: false }
}
export const getStaticPropsFactory = lang => async ({ params }) => {
const ret_props = await fetchPostShowData({ post_slug: params.post_slug, lang })
return {
props: ret_props
}
}
const Post = (props) => {
const PostComponent = PostComponentFactory(LANG)
return (
<PostComponent {...props}
lang={LANG}
pageName={props.post_title}
pageDesc={props.pageDesc}
pageImage={props.post_feature_image_url}
/>
)
}
export const getStaticPaths = getStaticPathsFactory(LANG)
export const getStaticProps = getStaticPropsFactory(LANG)
export default Post
|
/*global define*/
define([
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./DeveloperError',
'./Math',
'./Matrix3',
'./QuadraticRealPolynomial',
'./QuarticRealPolynomial',
'./Ray'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
DeveloperError,
CesiumMath,
Matrix3,
QuadraticRealPolynomial,
QuarticRealPolynomial,
Ray) {
"use strict";
/**
* Functions for computing the intersection between geometries such as rays, planes, triangles, and ellipsoids.
*
* @namespace
* @alias IntersectionTests
*/
var IntersectionTests = {};
/**
* Computes the intersection of a ray and a plane.
*
* @param {Ray} ray The ray.
* @param {Plane} plane The plane.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.rayPlane = function(ray, plane, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(plane)) {
throw new DeveloperError('plane is required.');
}
//>>includeEnd('debug');
if (!defined(result)) {
result = new Cartesian3();
}
var origin = ray.origin;
var direction = ray.direction;
var normal = plane.normal;
var denominator = Cartesian3.dot(normal, direction);
if (Math.abs(denominator) < CesiumMath.EPSILON15) {
// Ray is parallel to plane. The ray may be in the polygon's plane.
return undefined;
}
var t = (-plane.distance - Cartesian3.dot(normal, origin)) / denominator;
if (t < 0) {
return undefined;
}
result = Cartesian3.multiplyByScalar(direction, t, result);
return Cartesian3.add(origin, result, result);
};
var scratchEdge0 = new Cartesian3();
var scratchEdge1 = new Cartesian3();
var scratchPVec = new Cartesian3();
var scratchTVec = new Cartesian3();
var scratchQVec = new Cartesian3();
function rayTriangle(ray, p0, p1, p2, cullBackFaces) {
//>>includeStart('debug', pragmas.debug);
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(p0)) {
throw new DeveloperError('p0 is required.');
}
if (!defined(p1)) {
throw new DeveloperError('p1 is required.');
}
if (!defined(p2)) {
throw new DeveloperError('p2 is required.');
}
//>>includeEnd('debug');
cullBackFaces = defaultValue(cullBackFaces, false);
var origin = ray.origin;
var direction = ray.direction;
var edge0 = Cartesian3.subtract(p1, p0, scratchEdge0);
var edge1 = Cartesian3.subtract(p2, p0, scratchEdge1);
var p = Cartesian3.cross(direction, edge1, scratchPVec);
var det = Cartesian3.dot(edge0, p);
var tvec;
var q;
var u;
var v;
var t;
if (cullBackFaces) {
if (det < CesiumMath.EPSILON6) {
return undefined;
}
tvec = Cartesian3.subtract(origin, p0, scratchTVec);
u = Cartesian3.dot(tvec, p);
if (u < 0.0 || u > det) {
return undefined;
}
q = Cartesian3.cross(tvec, edge0, scratchQVec);
v = Cartesian3.dot(direction, q);
if (v < 0.0 || u + v > det) {
return undefined;
}
t = Cartesian3.dot(edge1, q) / det;
} else {
if (Math.abs(det) < CesiumMath.EPSILON6) {
return undefined;
}
var invDet = 1.0 / det;
tvec = Cartesian3.subtract(origin, p0, scratchTVec);
u = Cartesian3.dot(tvec, p) * invDet;
if (u < 0.0 || u > 1.0) {
return undefined;
}
q = Cartesian3.cross(tvec, edge0, scratchQVec);
v = Cartesian3.dot(direction, q) * invDet;
if (v < 0.0 || u + v > 1.0) {
return undefined;
}
t = Cartesian3.dot(edge1, q) * invDet;
}
return t;
}
/**
* Computes the intersection of a ray and a triangle.
* @memberof IntersectionTests
*
* @param {Ray} ray The ray.
* @param {Cartesian3} p0 The first vertex of the triangle.
* @param {Cartesian3} p1 The second vertex of the triangle.
* @param {Cartesian3} p2 The third vertex of the triangle.
* @param {Boolean} [cullBackFaces=false] If <code>true<code>, will only compute an intersection with the front face of the triangle
* and return undefined for intersections with the back face.
* @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.rayTriangle = function(ray, p0, p1, p2, cullBackFaces, result) {
var t = rayTriangle(ray, p0, p1, p2, cullBackFaces);
if (!defined(t) || t < 0.0) {
return undefined;
}
if (!defined(result)) {
result = new Cartesian3();
}
Cartesian3.multiplyByScalar(ray.direction, t, result);
return Cartesian3.add(ray.origin, result, result);
};
var scratchLineSegmentTriangleRay = new Ray();
/**
* Computes the intersection of a line segment and a triangle.
* @memberof IntersectionTests
*
* @param {Cartesian3} v0 The an end point of the line segment.
* @param {Cartesian3} v1 The other end point of the line segment.
* @param {Cartesian3} p0 The first vertex of the triangle.
* @param {Cartesian3} p1 The second vertex of the triangle.
* @param {Cartesian3} p2 The third vertex of the triangle.
* @param {Boolean} [cullBackFaces=false] If <code>true<code>, will only compute an intersection with the front face of the triangle
* and return undefined for intersections with the back face.
* @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.lineSegmentTriangle = function(v0, v1, p0, p1, p2, cullBackFaces, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(v0)) {
throw new DeveloperError('v0 is required.');
}
if (!defined(v1)) {
throw new DeveloperError('v1 is required.');
}
//>>includeEnd('debug');
var ray = scratchLineSegmentTriangleRay;
Cartesian3.clone(v0, ray.origin);
Cartesian3.subtract(v1, v0, ray.direction);
Cartesian3.normalize(ray.direction, ray.direction);
var t = rayTriangle(ray, p0, p1, p2, cullBackFaces);
if (!defined(t) || t < 0.0 || t > Cartesian3.distance(v0, v1)) {
return undefined;
}
if (!defined(result)) {
result = new Cartesian3();
}
Cartesian3.multiplyByScalar(ray.direction, t, result);
return Cartesian3.add(ray.origin, result, result);
};
function solveQuadratic(a, b, c, result) {
var det = b * b - 4.0 * a * c;
if (det < 0.0) {
return undefined;
} else if (det > 0.0) {
var denom = 1.0 / (2.0 * a);
var disc = Math.sqrt(det);
var root0 = (-b + disc) * denom;
var root1 = (-b - disc) * denom;
if (root0 < root1) {
result.root0 = root0;
result.root1 = root1;
} else {
result.root0 = root1;
result.root1 = root0;
}
return result;
}
var root = -b / (2.0 * a);
if (root === 0.0) {
return undefined;
}
result.root0 = result.root1 = root;
return result;
}
var raySphereRoots = {
root0 : 0.0,
root1 : 0.0
};
function raySphere(ray, sphere, result) {
if (!defined(result)) {
result = {};
}
var origin = ray.origin;
var direction = ray.direction;
var center = sphere.center;
var radiusSquared = sphere.radius * sphere.radius;
var diff = Cartesian3.subtract(origin, center, scratchPVec);
var a = Cartesian3.dot(direction, direction);
var b = 2.0 * Cartesian3.dot(direction, diff);
var c = Cartesian3.magnitudeSquared(diff) - radiusSquared;
var roots = solveQuadratic(a, b, c, raySphereRoots);
if (!defined(roots)) {
return undefined;
}
result.start = roots.root0;
result.stop = roots.root1;
return result;
}
/**
* Computes the intersection points of a ray with a sphere.
* @memberof IntersectionTests
*
* @param {Ray} ray The ray.
* @param {BoundingSphere} sphere The sphere.
* @param {Object} [result] The result onto which to store the result.
* @returns {Object} An object with the first (<code>start</code>) and the second (<code>stop</code>) intersection scalars for points along the ray or undefined if there are no intersections.
*/
IntersectionTests.raySphere = function(ray, sphere, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(sphere)) {
throw new DeveloperError('sphere is required.');
}
//>>includeEnd('debug');
result = raySphere(ray, sphere, result);
if (!defined(result) || result.stop < 0.0) {
return undefined;
}
result.start = Math.max(result.start, 0.0);
return result;
};
var scratchLineSegmentRay = new Ray();
/**
* Computes the intersection points of a line segment with a sphere.
* @memberof IntersectionTests
*
* @param {Cartesian3} p0 An end point of the line segment.
* @param {Cartesian3} p1 The other end point of the line segment.
* @param {BoundingSphere} sphere The sphere.
* @param {Object} [result] The result onto which to store the result.
* @returns {Object} An object with the first (<code>start</code>) and the second (<code>stop</code>) intersection scalars for points along the line segment or undefined if there are no intersections.
*/
IntersectionTests.lineSegmentSphere = function(p0, p1, sphere, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(p0)) {
throw new DeveloperError('p0 is required.');
}
if (!defined(p1)) {
throw new DeveloperError('p1 is required.');
}
if (!defined(sphere)) {
throw new DeveloperError('sphere is required.');
}
//>>includeEnd('debug');
var ray = scratchLineSegmentRay;
var origin = Cartesian3.clone(p0, ray.origin);
var direction = Cartesian3.subtract(p1, p0, ray.direction);
var maxT = Cartesian3.magnitude(direction);
Cartesian3.normalize(direction, direction);
result = raySphere(ray, sphere, result);
if (!defined(result) || result.stop < 0.0 || result.start > maxT) {
return undefined;
}
result.start = Math.max(result.start, 0.0);
result.stop = Math.min(result.stop, maxT);
return result;
};
var scratchQ = new Cartesian3();
var scratchW = new Cartesian3();
/**
* Computes the intersection points of a ray with an ellipsoid.
*
* @param {Ray} ray The ray.
* @param {Ellipsoid} ellipsoid The ellipsoid.
* @returns {Object} An object with the first (<code>start</code>) and the second (<code>stop</code>) intersection scalars for points along the ray or undefined if there are no intersections.
*/
IntersectionTests.rayEllipsoid = function(ray, ellipsoid) {
//>>includeStart('debug', pragmas.debug);
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(ellipsoid)) {
throw new DeveloperError('ellipsoid is required.');
}
//>>includeEnd('debug');
var inverseRadii = ellipsoid.oneOverRadii;
var q = Cartesian3.multiplyComponents(inverseRadii, ray.origin, scratchQ);
var w = Cartesian3.multiplyComponents(inverseRadii, ray.direction, scratchW);
var q2 = Cartesian3.magnitudeSquared(q);
var qw = Cartesian3.dot(q, w);
var difference, w2, product, discriminant, temp;
if (q2 > 1.0) {
// Outside ellipsoid.
if (qw >= 0.0) {
// Looking outward or tangent (0 intersections).
return undefined;
}
// qw < 0.0.
var qw2 = qw * qw;
difference = q2 - 1.0; // Positively valued.
w2 = Cartesian3.magnitudeSquared(w);
product = w2 * difference;
if (qw2 < product) {
// Imaginary roots (0 intersections).
return undefined;
} else if (qw2 > product) {
// Distinct roots (2 intersections).
discriminant = qw * qw - product;
temp = -qw + Math.sqrt(discriminant); // Avoid cancellation.
var root0 = temp / w2;
var root1 = difference / temp;
if (root0 < root1) {
return {
start : root0,
stop : root1
};
}
return {
start : root1,
stop : root0
};
} else {
// qw2 == product. Repeated roots (2 intersections).
var root = Math.sqrt(difference / w2);
return {
start : root,
stop : root
};
}
} else if (q2 < 1.0) {
// Inside ellipsoid (2 intersections).
difference = q2 - 1.0; // Negatively valued.
w2 = Cartesian3.magnitudeSquared(w);
product = w2 * difference; // Negatively valued.
discriminant = qw * qw - product;
temp = -qw + Math.sqrt(discriminant); // Positively valued.
return {
start : 0.0,
stop : temp / w2
};
} else {
// q2 == 1.0. On ellipsoid.
if (qw < 0.0) {
// Looking inward.
w2 = Cartesian3.magnitudeSquared(w);
return {
start : 0.0,
stop : -qw / w2
};
}
// qw >= 0.0. Looking outward or tangent.
return undefined;
}
};
function addWithCancellationCheck(left, right, tolerance) {
var difference = left + right;
if ((CesiumMath.sign(left) !== CesiumMath.sign(right)) &&
Math.abs(difference / Math.max(Math.abs(left), Math.abs(right))) < tolerance) {
return 0.0;
}
return difference;
}
function quadraticVectorExpression(A, b, c, x, w) {
var xSquared = x * x;
var wSquared = w * w;
var l2 = (A[Matrix3.COLUMN1ROW1] - A[Matrix3.COLUMN2ROW2]) * wSquared;
var l1 = w * (x * addWithCancellationCheck(A[Matrix3.COLUMN1ROW0], A[Matrix3.COLUMN0ROW1], CesiumMath.EPSILON15) + b.y);
var l0 = (A[Matrix3.COLUMN0ROW0] * xSquared + A[Matrix3.COLUMN2ROW2] * wSquared) + x * b.x + c;
var r1 = wSquared * addWithCancellationCheck(A[Matrix3.COLUMN2ROW1], A[Matrix3.COLUMN1ROW2], CesiumMath.EPSILON15);
var r0 = w * (x * addWithCancellationCheck(A[Matrix3.COLUMN2ROW0], A[Matrix3.COLUMN0ROW2]) + b.z);
var cosines;
var solutions = [];
if (r0 === 0.0 && r1 === 0.0) {
cosines = QuadraticRealPolynomial.computeRealRoots(l2, l1, l0);
if (cosines.length === 0) {
return solutions;
}
var cosine0 = cosines[0];
var sine0 = Math.sqrt(Math.max(1.0 - cosine0 * cosine0, 0.0));
solutions.push(new Cartesian3(x, w * cosine0, w * -sine0));
solutions.push(new Cartesian3(x, w * cosine0, w * sine0));
if (cosines.length === 2) {
var cosine1 = cosines[1];
var sine1 = Math.sqrt(Math.max(1.0 - cosine1 * cosine1, 0.0));
solutions.push(new Cartesian3(x, w * cosine1, w * -sine1));
solutions.push(new Cartesian3(x, w * cosine1, w * sine1));
}
return solutions;
}
var r0Squared = r0 * r0;
var r1Squared = r1 * r1;
var l2Squared = l2 * l2;
var r0r1 = r0 * r1;
var c4 = l2Squared + r1Squared;
var c3 = 2.0 * (l1 * l2 + r0r1);
var c2 = 2.0 * l0 * l2 + l1 * l1 - r1Squared + r0Squared;
var c1 = 2.0 * (l0 * l1 - r0r1);
var c0 = l0 * l0 - r0Squared;
if (c4 === 0.0 && c3 === 0.0 && c2 === 0.0 && c1 === 0.0) {
return solutions;
}
cosines = QuarticRealPolynomial.computeRealRoots(c4, c3, c2, c1, c0);
var length = cosines.length;
if (length === 0) {
return solutions;
}
for ( var i = 0; i < length; ++i) {
var cosine = cosines[i];
var cosineSquared = cosine * cosine;
var sineSquared = Math.max(1.0 - cosineSquared, 0.0);
var sine = Math.sqrt(sineSquared);
//var left = l2 * cosineSquared + l1 * cosine + l0;
var left;
if (CesiumMath.sign(l2) === CesiumMath.sign(l0)) {
left = addWithCancellationCheck(l2 * cosineSquared + l0, l1 * cosine, CesiumMath.EPSILON12);
} else if (CesiumMath.sign(l0) === CesiumMath.sign(l1 * cosine)) {
left = addWithCancellationCheck(l2 * cosineSquared, l1 * cosine + l0, CesiumMath.EPSILON12);
} else {
left = addWithCancellationCheck(l2 * cosineSquared + l1 * cosine, l0, CesiumMath.EPSILON12);
}
var right = addWithCancellationCheck(r1 * cosine, r0, CesiumMath.EPSILON15);
var product = left * right;
if (product < 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * sine));
} else if (product > 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * -sine));
} else if (sine !== 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * -sine));
solutions.push(new Cartesian3(x, w * cosine, w * sine));
++i;
} else {
solutions.push(new Cartesian3(x, w * cosine, w * sine));
}
}
return solutions;
}
var firstAxisScratch = new Cartesian3();
var secondAxisScratch = new Cartesian3();
var thirdAxisScratch = new Cartesian3();
var referenceScratch = new Cartesian3();
var bCart = new Cartesian3();
var bScratch = new Matrix3();
var btScratch = new Matrix3();
var diScratch = new Matrix3();
var dScratch = new Matrix3();
var cScratch = new Matrix3();
var tempMatrix = new Matrix3();
var aScratch = new Matrix3();
var sScratch = new Cartesian3();
var closestScratch = new Cartesian3();
var surfPointScratch = new Cartographic();
/**
* Provides the point along the ray which is nearest to the ellipsoid.
*
* @param {Ray} ray The ray.
* @param {Ellipsoid} ellipsoid The ellipsoid.
* @returns {Cartesian} The nearest planetodetic point on the ray.
*/
IntersectionTests.grazingAltitudeLocation = function(ray, ellipsoid) {
//>>includeStart('debug', pragmas.debug);
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(ellipsoid)) {
throw new DeveloperError('ellipsoid is required.');
}
//>>includeEnd('debug');
var position = ray.origin;
var direction = ray.direction;
var normal = ellipsoid.geodeticSurfaceNormal(position, firstAxisScratch);
if (Cartesian3.dot(direction, normal) >= 0.0) { // The location provided is the closest point in altitude
return position;
}
var intersects = defined(this.rayEllipsoid(ray, ellipsoid));
// Compute the scaled direction vector.
var f = ellipsoid.transformPositionToScaledSpace(direction, firstAxisScratch);
// Constructs a basis from the unit scaled direction vector. Construct its rotation and transpose.
var firstAxis = Cartesian3.normalize(f, f);
var reference = Cartesian3.mostOrthogonalAxis(f, referenceScratch);
var secondAxis = Cartesian3.normalize(Cartesian3.cross(reference, firstAxis, secondAxisScratch), secondAxisScratch);
var thirdAxis = Cartesian3.normalize(Cartesian3.cross(firstAxis, secondAxis, thirdAxisScratch), thirdAxisScratch);
var B = bScratch;
B[0] = firstAxis.x;
B[1] = firstAxis.y;
B[2] = firstAxis.z;
B[3] = secondAxis.x;
B[4] = secondAxis.y;
B[5] = secondAxis.z;
B[6] = thirdAxis.x;
B[7] = thirdAxis.y;
B[8] = thirdAxis.z;
var B_T = Matrix3.transpose(B, btScratch);
// Get the scaling matrix and its inverse.
var D_I = Matrix3.fromScale(ellipsoid.radii, diScratch);
var D = Matrix3.fromScale(ellipsoid.oneOverRadii, dScratch);
var C = cScratch;
C[0] = 0.0;
C[1] = -direction.z;
C[2] = direction.y;
C[3] = direction.z;
C[4] = 0.0;
C[5] = -direction.x;
C[6] = -direction.y;
C[7] = direction.x;
C[8] = 0.0;
var temp = Matrix3.multiply(Matrix3.multiply(B_T, D, tempMatrix), C, tempMatrix);
var A = Matrix3.multiply(Matrix3.multiply(temp, D_I, aScratch), B, aScratch);
var b = Matrix3.multiplyByVector(temp, position, bCart);
// Solve for the solutions to the expression in standard form:
var solutions = quadraticVectorExpression(A, Cartesian3.negate(b, firstAxisScratch), 0.0, 0.0, 1.0);
var s;
var altitude;
var length = solutions.length;
if (length > 0) {
var closest = Cartesian3.clone(Cartesian3.ZERO, closestScratch);
var maximumValue = Number.NEGATIVE_INFINITY;
for ( var i = 0; i < length; ++i) {
s = Matrix3.multiplyByVector(D_I, Matrix3.multiplyByVector(B, solutions[i], sScratch), sScratch);
var v = Cartesian3.normalize(Cartesian3.subtract(s, position, referenceScratch), referenceScratch);
var dotProduct = Cartesian3.dot(v, direction);
if (dotProduct > maximumValue) {
maximumValue = dotProduct;
closest = Cartesian3.clone(s, closest);
}
}
var surfacePoint = ellipsoid.cartesianToCartographic(closest, surfPointScratch);
maximumValue = CesiumMath.clamp(maximumValue, 0.0, 1.0);
altitude = Cartesian3.magnitude(Cartesian3.subtract(closest, position, referenceScratch)) * Math.sqrt(1.0 - maximumValue * maximumValue);
altitude = intersects ? -altitude : altitude;
surfacePoint.height = altitude;
return ellipsoid.cartographicToCartesian(surfacePoint, new Cartesian3());
}
return undefined;
};
var lineSegmentPlaneDifference = new Cartesian3();
/**
* Computes the intersection of a line segment and a plane.
*
* @param {Cartesian3} endPoint0 An end point of the line segment.
* @param {Cartesian3} endPoint1 The other end point of the line segment.
* @param {Plane} plane The plane.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersection.
*
* @example
* var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
* var normal = ellipsoid.geodeticSurfaceNormal(origin);
* var plane = Cesium.Plane.fromPointNormal(origin, normal);
*
* var p0 = new Cesium.Cartesian3(...);
* var p1 = new Cesium.Cartesian3(...);
*
* // find the intersection of the line segment from p0 to p1 and the tangent plane at origin.
* var intersection = Cesium.IntersectionTests.lineSegmentPlane(p0, p1, plane);
*/
IntersectionTests.lineSegmentPlane = function(endPoint0, endPoint1, plane, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(endPoint0)) {
throw new DeveloperError('endPoint0 is required.');
}
if (!defined(endPoint1)) {
throw new DeveloperError('endPoint1 is required.');
}
if (!defined(plane)) {
throw new DeveloperError('plane is required.');
}
//>>includeEnd('debug');
if (!defined(result)) {
result = new Cartesian3();
}
var difference = Cartesian3.subtract(endPoint1, endPoint0, lineSegmentPlaneDifference);
var normal = plane.normal;
var nDotDiff = Cartesian3.dot(normal, difference);
// check if the segment and plane are parallel
if (Math.abs(nDotDiff) < CesiumMath.EPSILON6) {
return undefined;
}
var nDotP0 = Cartesian3.dot(normal, endPoint0);
var t = -(plane.distance + nDotP0) / nDotDiff;
// intersection only if t is in [0, 1]
if (t < 0.0 || t > 1.0) {
return undefined;
}
// intersection is endPoint0 + t * (endPoint1 - endPoint0)
Cartesian3.multiplyByScalar(difference, t, result);
Cartesian3.add(endPoint0, result, result);
return result;
};
/**
* Computes the intersection of a triangle and a plane
*
* @param {Cartesian3} p0 First point of the triangle
* @param {Cartesian3} p1 Second point of the triangle
* @param {Cartesian3} p2 Third point of the triangle
* @param {Plane} plane Intersection plane
* @returns {Object} An object with properties <code>positions</code> and <code>indices</code>, which are arrays that represent three triangles that do not cross the plane. (Undefined if no intersection exists)
*
* @example
* var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
* var normal = ellipsoid.geodeticSurfaceNormal(origin);
* var plane = Cesium.Plane.fromPointNormal(origin, normal);
*
* var p0 = new Cesium.Cartesian3(...);
* var p1 = new Cesium.Cartesian3(...);
* var p2 = new Cesium.Cartesian3(...);
*
* // convert the triangle composed of points (p0, p1, p2) to three triangles that don't cross the plane
* var triangles = Cesium.IntersectionTests.trianglePlaneIntersection(p0, p1, p2, plane);
*/
IntersectionTests.trianglePlaneIntersection = function(p0, p1, p2, plane) {
//>>includeStart('debug', pragmas.debug);
if ((!defined(p0)) ||
(!defined(p1)) ||
(!defined(p2)) ||
(!defined(plane))) {
throw new DeveloperError('p0, p1, p2, and plane are required.');
}
//>>includeEnd('debug');
var planeNormal = plane.normal;
var planeD = plane.distance;
var p0Behind = (Cartesian3.dot(planeNormal, p0) + planeD) < 0.0;
var p1Behind = (Cartesian3.dot(planeNormal, p1) + planeD) < 0.0;
var p2Behind = (Cartesian3.dot(planeNormal, p2) + planeD) < 0.0;
// Given these dots products, the calls to lineSegmentPlaneIntersection
// always have defined results.
var numBehind = 0;
numBehind += p0Behind ? 1 : 0;
numBehind += p1Behind ? 1 : 0;
numBehind += p2Behind ? 1 : 0;
var u1, u2;
if (numBehind === 1 || numBehind === 2) {
u1 = new Cartesian3();
u2 = new Cartesian3();
}
if (numBehind === 1) {
if (p0Behind) {
IntersectionTests.lineSegmentPlane(p0, p1, plane, u1);
IntersectionTests.lineSegmentPlane(p0, p2, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
0, 3, 4,
// In front
1, 2, 4,
1, 4, 3
]
};
} else if (p1Behind) {
IntersectionTests.lineSegmentPlane(p1, p2, plane, u1);
IntersectionTests.lineSegmentPlane(p1, p0, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
1, 3, 4,
// In front
2, 0, 4,
2, 4, 3
]
};
} else if (p2Behind) {
IntersectionTests.lineSegmentPlane(p2, p0, plane, u1);
IntersectionTests.lineSegmentPlane(p2, p1, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
2, 3, 4,
// In front
0, 1, 4,
0, 4, 3
]
};
}
} else if (numBehind === 2) {
if (!p0Behind) {
IntersectionTests.lineSegmentPlane(p1, p0, plane, u1);
IntersectionTests.lineSegmentPlane(p2, p0, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
1, 2, 4,
1, 4, 3,
// In front
0, 3, 4
]
};
} else if (!p1Behind) {
IntersectionTests.lineSegmentPlane(p2, p1, plane, u1);
IntersectionTests.lineSegmentPlane(p0, p1, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
2, 0, 4,
2, 4, 3,
// In front
1, 3, 4
]
};
} else if (!p2Behind) {
IntersectionTests.lineSegmentPlane(p0, p2, plane, u1);
IntersectionTests.lineSegmentPlane(p1, p2, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
0, 1, 4,
0, 4, 3,
// In front
2, 3, 4
]
};
}
}
// if numBehind is 3, the triangle is completely behind the plane;
// otherwise, it is completely in front (numBehind is 0).
return undefined;
};
return IntersectionTests;
});
|
// Create array from node string
stringToArray: function() {
return arguments[0].replace(/ /g, "").split("@").slice(1);
}
|
'use strict';
exports.BattleMovedex = {
"infgun": {
id: "infgun",
name: "INF Gun",
basePower: 50,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Flame Burst", target);
},
target: "normal",
type: "INF",
},
"bazooka": {
id: "bazooka",
name: "Bazooka",
basePower: 100,
pp: 3,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Octazooka", target);
},
target: "normal",
type: "MECH",
},
"mechgun": {
id: "mechgun",
name: "Mech Gun",
basePower: 60,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Metal Burst", target);
},
target: "normal",
type: "INF",
},
"mgun": {
id: "mgun",
name: "M Gun",
basePower: 65,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Foresight", target);
},
target: "normal",
type: "RM",
},
"lcannon": {
id: "lcannon",
name: "LCannon",
basePower: 100,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Flash Cannon", target);
},
target: "normal",
type: "LTank",
},
"tankgun": {
id: "tankgun",
name: "Tank Gun",
basePower: 70,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Fire Blast", target);
},
target: "normal",
type: "INF",
},
"mdcannon": {
id: "mdcannon",
name: "MDCannon",
basePower: 150,
pp: 6,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Flash Cannon", target);
},
target: "normal",
type: "MDTank",
},
"mdtankgun": {
id: "mdtankgun",
name: "MDTank Gun",
basePower: 80,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Inferno", target);
},
target: "normal",
type: "INF",
},
"neocannon": {
id: "neocannon",
name: "Neocannon",
basePower: 200,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Flash Cannon", target);
},
target: "normal",
type: "Neotank",
},
"neogun": {
id: "neogun",
name: "NeoGun",
basePower: 200,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Incinerate", target);
},
target: "normal",
type: "INF",
},
"artilleryception": {
id: "artilleryception",
name: "Artilleryception",
basePower: 100,
pp: 6,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "AC",
},
"missileception": {
id: "missileception",
name: "Missileception",
basePower: 150,
pp: 6,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "MC",
},
"rocketception": {
id: "rocketception",
name: "Rocketception",
basePower: 150,
pp: 6,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "RC",
},
"battleception": {
id: "battleception",
name: "Battleception",
basePower: 200,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "BC",
},
"torps": {
id: "torps",
name: "Torps",
basePower: 200,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Fire Blast", target);
},
target: "normal",
type: "ST",
},
"cmissiles": {
id: "cmissiles",
name: "CMissiles",
basePower: 150,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "CM",
},
"aairgun": {
id: "aairgun",
name: "A-Air Gun",
basePower: 150,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet Bomb", target);
},
target: "normal",
type: "AAG",
},
"vulcan": {
id: "vulcan",
name: "Vulcan",
basePower: 150,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Incinerate", target);
},
target: "normal",
type: "Vul",
},
"bmissile": {
id: "bmissile",
name: "BMissile",
basePower: 125,
pp: 6,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Sinister Arrow Raid", target);
},
target: "normal",
type: "BM",
},
"bcoptergun": {
id: "bcoptergun",
name: "BCopter Gun",
basePower: 75,
pp: 99,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Smart Strike", target);
},
target: "normal",
type: "BCGun",
},
"fmissiles": {
id: "fmissiles",
name: "FMissiles",
basePower: 150,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Focus Blast", target);
},
target: "normal",
type: "Fighter",
},
"bombs": {
id: "bombs",
name: "Bombs",
basePower: 255,
pp: 9,
accuracy: true,
category: "Special",
secondary: false,
priority: false,
flags: {protect: 1},
onHit: function (target, source) {
this.attrLastMove('[still]');
this.add('-anim', source, "Seed Bomb", target);
this.add('-anim', source, "Egg Bomb", target);
this.add('-anim', source, "Magnet", target);
this.add('-anim', source, "Sinister Arrow Raid", target);
},
target: "normal",
type: "Bomber",
},
};
|
'use strict';
module.exports = (event, state, args, next) => {
let data = event.data || {};
let nodeId = data.node ? (data.node.id || data.node) : null;
if (!state.VIS) {
return next(new Error('Flow-visualizer: No flow-visualizer instance found on state.'));
}
if (!data.event || !data.event.keyCode) {
return next(new Error('Flow-visualizer.navigate: No keyCode provided.'));
}
let direction;
switch (data.event.keyCode) {
case 37:
direction = 'left';
break;
case 38:
direction = 'up';
break;
case 39:
direction = 'right';
break;
case 40:
direction = 'down';
};
if (!direction) {
return next(new Error('Flow-visualizer.navigate: Invalid direction provided.'));
}
let result = state.VIS.navigate(direction, nodeId);
if (result) {
console.log(result);
//event.flow(state.events.navigationNode, {node: result});
}
next();
};
|
(function() {
'use strict';
define([
'dessert.component'
], main);
function main(
Component
) {
class Box extends Component {
static get name() { return 'box'; }
render() {
return `<div class="box"></div>`;
}
init(wrapper) {
var box = wrapper.element;
var expanding = false;
var dimensions = 100;
box.click(function() {
if (expanding) {
box.stop().animate({
width: '50px',
height: '50px'
});
expanding = false;
} else {
dimensions = prompt('What width and height would you like to expand to?', '100');
dimensions = dimensions.replace(/[a-z]+$/gi, ''); //remove any trailing units (px, em, etc)
dimensions = parseInt(dimensions) || 100;
dimensions = `${dimensions}px`;
box.stop().animate({
width: dimensions,
height: dimensions
});
expanding = true;
}
});
}
}
return Box;
}
})();
|
const DrawCard = require('../../drawcard.js');
const { Players, CardTypes } = require('../../Constants');
class StewardOfLaw extends DrawCard {
setupCardAbilities(ability) {
this.persistentEffect({
condition: context => context.source.isParticipating(),
targetController: Players.Any,
match: card => card.getType() === CardTypes.Character,
effect: ability.effects.cardCannot('receiveDishonorToken')
});
}
}
StewardOfLaw.id = 'steward-of-law';
module.exports = StewardOfLaw;
|
const test = require('ava')
, { everyPred } = require('../dist/redash')
test('returns true if all predicates pass', (t) => {
t.true(everyPred([
() => true
, () => true
], 8))
})
test('returns false if any predicate fails', (t) => {
t.false(everyPred([
() => true
, () => false
], 7))
})
test('returns true if there the predicates list is empty', (t) => {
t.true(everyPred([], 7))
})
|
import React from 'react';
import { expect } from 'chai';
import { shallow, mount } from 'enzyme';
import sinon from 'sinon';
import { scaleLinear } from 'd3';
import Slider from '../src/slider';
import SliderHandle from '../src/slider-handle';
describe('ChoroplethLegend <Slider />', () => {
const domain = [0, 100];
const width = 1000;
const xScale = scaleLinear()
.domain(domain)
.range([0, width])
.clamp(true);
const onSliderMove = sinon.spy((extent) => extent);
const minExtent = 25;
const maxExtent = 75;
describe('responds to range extent', () => {
const wrapper = shallow(
<Slider
domain={domain}
xScale={xScale}
rangeExtent={[minExtent, maxExtent]}
width={width}
onSliderMove={onSliderMove}
/>
);
it('places brush handles on the left and ridge edges of the range extent', () => {
expect(wrapper.find(SliderHandle).first()).to.have.prop('position', xScale(minExtent));
expect(wrapper.find(SliderHandle).last()).to.have.prop('position', xScale(maxExtent));
});
it('produces gray rects of appropriate width based on range extent', () => {
expect(wrapper.find('rect').first()).to.have.attr('width', `${xScale(minExtent)}`);
expect(wrapper.find('rect').last()).to.have.attr('width', `${width - xScale(maxExtent)}`);
});
});
describe('publishes updated range extent', () => {
let wrapper;
beforeEach(() => {
wrapper = mount(
<Slider
domain={domain}
xScale={xScale}
rangeExtent={[minExtent, maxExtent]}
width={width}
onSliderMove={onSliderMove}
/>
);
onSliderMove.reset();
});
afterEach(() => {
wrapper.unmount();
});
it('supplied sliderMove evt is triggered by dragmove event on brush handles ', () => {
expect(onSliderMove.callCount).to.equal(0);
wrapper.find(SliderHandle).first().instance()
.onHandleMove({ dx: 10 });
expect(onSliderMove.callCount).to.equal(1);
});
it('does not trigger supplied sliderMove evt when handle is moved off slider', () => {
expect(onSliderMove.callCount).to.equal(0);
wrapper.find(SliderHandle).last().instance()
.onHandleMove({ dx: 300 });
expect(onSliderMove.callCount).to.equal(0);
});
it('snaps to bounds of slider within tolerance', () => {
wrapper.find(SliderHandle).first().instance()
.onHandleMove({ dx: -248 });
expect(onSliderMove.lastCall.args[0]).to.deep.equal([0, 0.75]);
wrapper.find(SliderHandle).last().instance()
.onHandleMove({ dx: 248 });
expect(onSliderMove.lastCall.args[0]).to.deep.equal([0.25, 1]);
});
});
});
|
YUI.add("datasource-polling",function(e,t){function n(){this._intervals={}}n.prototype={_intervals:null,setInterval:function(t,n){var r=e.later(t,this,this.sendRequest,[n],!0);return this._intervals[r.id]=r,e.later(0,this,this.sendRequest,[n]),r.id},clearInterval:function(e,t){e=t||e,this._intervals[e]&&(this._intervals[e].cancel(),delete this._intervals[e])},clearAllIntervals:function(){e.each(this._intervals,this.clearInterval,this)}},e.augment(e.DataSource.Local,n)},"patched-v3.18.0",{requires:["datasource-local"]});
|
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
import _extends from "@babel/runtime/helpers/esm/extends";
import styled from '@material-ui/styled-engine';
import { unstable_styleFunctionSx as styleFunctionSx } from '@material-ui/system';
import propsToClassKey from './propsToClassKey';
import defaultTheme from './defaultTheme';
function isEmpty(obj) {
return Object.keys(obj).length === 0;
}
const getStyleOverrides = (name, theme) => {
if (theme.components && theme.components[name] && theme.components[name].styleOverrides) {
return theme.components[name].styleOverrides;
}
return null;
};
const getVariantStyles = (name, theme) => {
let variants = [];
if (theme && theme.components && theme.components[name] && theme.components[name].variants) {
variants = theme.components[name].variants;
}
const variantsStyles = {};
variants.forEach(definition => {
const key = propsToClassKey(definition.props);
variantsStyles[key] = definition.style;
});
return variantsStyles;
};
const variantsResolver = (props, styles, theme, name) => {
const {
styleProps = {}
} = props;
let variantsStyles = {};
const themeVariants = theme?.components?.[name]?.variants;
if (themeVariants) {
themeVariants.forEach(themeVariant => {
let isMatch = true;
Object.keys(themeVariant.props).forEach(key => {
if (styleProps[key] !== themeVariant.props[key] && props[key] !== themeVariant.props[key]) {
isMatch = false;
}
});
if (isMatch) {
variantsStyles = _extends({}, variantsStyles, styles[propsToClassKey(themeVariant.props)]);
}
});
}
return variantsStyles;
};
export const rootShouldForwardProp = prop => prop !== 'styleProps' && prop !== 'theme' && prop !== 'isRtl' && prop !== 'sx' && prop !== 'as' && prop !== 'classes';
export const slotShouldForwardProp = prop => prop !== 'styleProps' && prop !== 'theme' && prop !== 'isRtl' && prop !== 'sx' && prop !== 'as';
const lowercaseFirstLetter = string => {
return string.charAt(0).toLowerCase() + string.slice(1);
};
const experimentalStyled = (tag, options, muiOptions = {}) => {
const componentName = muiOptions.name;
const componentSlot = muiOptions.slot;
const overridesResolver = muiOptions.overridesResolver; // if skipVariantsResolver option is defined, take the value, otherwise, true for root and false for other slots
const skipVariantsResolver = muiOptions.skipVariantsResolver !== undefined ? muiOptions.skipVariantsResolver : componentSlot && componentSlot !== 'Root' || false;
const skipSx = muiOptions.skipSx || false;
let displayName;
let className;
if (componentName) {
displayName = `${componentName}${componentSlot || ''}`;
className = `${componentName}-${lowercaseFirstLetter(componentSlot || 'Root')}`;
}
const defaultStyledResolver = styled(tag, _extends({}, !componentSlot || componentSlot === 'Root' ? {
shouldForwardProp: rootShouldForwardProp
} : {
shouldForwardProp: slotShouldForwardProp
}, {
label: className || componentName || ''
}, options));
const muiStyledResolver = (styleArg, ...expressions) => {
const expressionsWithDefaultTheme = expressions ? expressions.map(stylesArg => {
return typeof stylesArg === 'function' ? (_ref) => {
let {
theme: themeInput
} = _ref,
other = _objectWithoutPropertiesLoose(_ref, ["theme"]);
return stylesArg(_extends({
theme: isEmpty(themeInput) ? defaultTheme : themeInput
}, other));
} : stylesArg;
}) : [];
let transformedStyleArg = styleArg;
if (componentName && overridesResolver) {
expressionsWithDefaultTheme.push(props => {
const theme = isEmpty(props.theme) ? defaultTheme : props.theme;
const styleOverrides = getStyleOverrides(componentName, theme);
if (styleOverrides) {
return overridesResolver(props, styleOverrides);
}
return null;
});
}
if (componentName && overridesResolver && !skipVariantsResolver) {
expressionsWithDefaultTheme.push(props => {
const theme = isEmpty(props.theme) ? defaultTheme : props.theme;
return variantsResolver(props, getVariantStyles(componentName, theme), theme, componentName);
});
}
if (!skipSx) {
expressionsWithDefaultTheme.push(props => {
const theme = isEmpty(props.theme) ? defaultTheme : props.theme;
return styleFunctionSx(_extends({}, props, {
theme
}));
});
}
const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
const placeholders = new Array(numOfCustomFnsApplied).fill(''); // If the type is array, than we need to add placeholders in the template for the overrides, variants and the sx styles
transformedStyleArg = [...styleArg, ...placeholders];
transformedStyleArg.raw = [...styleArg.raw, ...placeholders];
} else if (typeof styleArg === 'function') {
// If the type is function, we need to define the default theme
transformedStyleArg = (_ref2) => {
let {
theme: themeInput
} = _ref2,
other = _objectWithoutPropertiesLoose(_ref2, ["theme"]);
return styleArg(_extends({
theme: isEmpty(themeInput) ? defaultTheme : themeInput
}, other));
};
}
const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme);
if (displayName) {
Component.displayName = displayName;
}
return Component;
};
return muiStyledResolver;
};
export default experimentalStyled;
|
/*global define*/
define(function() {
"use strict";
/**
* This enumerated type is for classifying mouse events: down, up, click, double click, move and move while a button is held down.
*
* @exports ScreenSpaceEventType
*/
var ScreenSpaceEventType = {
/**
* Represents a mouse left button down event.
*
* @type {Number}
* @constant
*/
LEFT_DOWN : 0,
/**
* Represents a mouse left button up event.
*
* @type {Number}
* @constant
*/
LEFT_UP : 1,
/**
* Represents a mouse left click event.
*
* @type {Number}
* @constant
*/
LEFT_CLICK : 2,
/**
* Represents a mouse left double click event.
*
* @type {Number}
* @constant
*/
LEFT_DOUBLE_CLICK : 3,
/**
* Represents a mouse left button down event.
*
* @type {Number}
* @constant
*/
RIGHT_DOWN : 5,
/**
* Represents a mouse right button up event.
*
* @type {Number}
* @constant
*/
RIGHT_UP : 6,
/**
* Represents a mouse right click event.
*
* @type {Number}
* @constant
*/
RIGHT_CLICK : 7,
/**
* Represents a mouse right double click event.
*
* @type {Number}
* @constant
*/
RIGHT_DOUBLE_CLICK : 8,
/**
* Represents a mouse middle button down event.
*
* @type {Number}
* @constant
*/
MIDDLE_DOWN : 10,
/**
* Represents a mouse middle button up event.
*
* @type {Number}
* @constant
*/
MIDDLE_UP : 11,
/**
* Represents a mouse middle click event.
*
* @type {Number}
* @constant
*/
MIDDLE_CLICK : 12,
/**
* Represents a mouse middle double click event.
*
* @type {Number}
* @constant
*/
MIDDLE_DOUBLE_CLICK : 13,
/**
* Represents a mouse move event.
*
* @type {Number}
* @constant
*/
MOUSE_MOVE : 15,
/**
* Represents a mouse wheel event.
*
* @type {Number}
* @constant
*/
WHEEL : 16,
/**
* Represents the start of a two-finger event on a touch surface.
*
* @type {Number}
* @constant
*/
PINCH_START : 17,
/**
* Represents the end of a two-finger event on a touch surface.
*
* @type {Number}
* @constant
*/
PINCH_END : 18,
/**
* Represents a change of a two-finger event on a touch surface.
*
* @type {Number}
* @constant
*/
PINCH_MOVE : 19
};
return ScreenSpaceEventType;
});
|
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2019 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Components = require('./components');
var GetFastValue = require('../../utils/object/GetFastValue');
var Vector2 = require('../../math/Vector2');
/**
* Internal function to check if the object has a getter or setter.
*
* @function hasGetterOrSetter
* @private
*
* @param {object} def - The object to check.
*
* @return {boolean} True if it has a getter or setter, otherwise false.
*/
function hasGetterOrSetter (def)
{
return (!!def.get && typeof def.get === 'function') || (!!def.set && typeof def.set === 'function');
}
/**
* [description]
*
* @function Phaser.Physics.Matter.MatterGameObject
* @since 3.3.0
*
* @param {Phaser.Physics.Matter.World} world - The Matter world to add the body to.
* @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will have the Matter body applied to it.
* @param {(object|MatterJS.Body)} options - A Matter Body configuration object, or an instance of a Matter Body.
*
* @return {Phaser.GameObjects.GameObject} The Game Object that was created with the Matter body.
*/
var MatterGameObject = function (world, gameObject, options)
{
if (options === undefined) { options = {}; }
var x = gameObject.x;
var y = gameObject.y;
// Temp body pos to avoid body null checks
gameObject.body = {
temp: true,
position: {
x: x,
y: y
}
};
var mixins = [
Components.Bounce,
Components.Collision,
Components.Force,
Components.Friction,
Components.Gravity,
Components.Mass,
Components.Sensor,
Components.SetBody,
Components.Sleep,
Components.Static,
Components.Transform,
Components.Velocity
];
// First let's inject all of the components into the Game Object
mixins.forEach(function (mixin)
{
for (var key in mixin)
{
if (hasGetterOrSetter(mixin[key]))
{
Object.defineProperty(gameObject, key, {
get: mixin[key].get,
set: mixin[key].set
});
}
else
{
Object.defineProperty(gameObject, key, {value: mixin[key]});
}
}
});
gameObject.world = world;
gameObject._tempVec2 = new Vector2(x, y);
if (options.hasOwnProperty('type') && options.type === 'body')
{
gameObject.setExistingBody(options, true);
}
else
{
var shape = GetFastValue(options, 'shape', null);
if (!shape)
{
shape = 'rectangle';
}
gameObject.setBody(shape, options);
}
return gameObject;
};
module.exports = MatterGameObject;
|
var classtesting_1_1_test_part_result_array =
[
[ "TestPartResultArray", "classtesting_1_1_test_part_result_array.html#ac9bfc830989c5328d7ff2ba8fa3c072b", null ],
[ "TestPartResultArray", "classtesting_1_1_test_part_result_array.html#ac9bfc830989c5328d7ff2ba8fa3c072b", null ],
[ "Append", "classtesting_1_1_test_part_result_array.html#a01844bd505b18a666324617a1b459558", null ],
[ "Append", "classtesting_1_1_test_part_result_array.html#a01844bd505b18a666324617a1b459558", null ],
[ "GetTestPartResult", "classtesting_1_1_test_part_result_array.html#a2b3dbf4012f204d916ce4a374bc03da4", null ],
[ "GetTestPartResult", "classtesting_1_1_test_part_result_array.html#a2b3dbf4012f204d916ce4a374bc03da4", null ],
[ "size", "classtesting_1_1_test_part_result_array.html#acd805ad4edda06d983456b2a30760dce", null ],
[ "size", "classtesting_1_1_test_part_result_array.html#acd805ad4edda06d983456b2a30760dce", null ]
];
|
(function() {
'use strict';
angular
.module('region', ['ngResource']);
})();
|
import { http } from '../net/http.js';
class CssHandler {
constructor() {
this.maxRetries = 0;
}
load(url, callback) {
if (typeof url === 'string') {
url = {
load: url,
original: url
};
}
http.get(url.load, {
retry: this.maxRetries > 0,
maxRetries: this.maxRetries
}, function (err, response) {
if (!err) {
callback(null, response);
} else {
callback(`Error loading css resource: ${url.original} [${err}]`);
}
});
}
open(url, data) {
return data;
}
patch(asset, assets) {
}
}
/**
* Creates a <style> DOM element from a string that contains CSS.
*
* @param {string} cssString - A string that contains valid CSS.
* @returns {Element} The style DOM element.
* @example
* var css = 'body {height: 100;}';
* var style = pc.createStyle(css);
* document.head.appendChild(style);
*/
function createStyle(cssString) {
const result = document.createElement('style');
result.type = 'text/css';
if (result.styleSheet) {
result.styleSheet.cssText = cssString;
} else {
result.appendChild(document.createTextNode(cssString));
}
return result;
}
export { createStyle, CssHandler };
|
/*!
* Clean Blog v1.0.0 (http://startbootstrap.com)
* Copyright 2014 Start Bootstrap
* Licensed under Apache 2.0 (https://github.com/IronSummitMedia/startbootstrap/blob/gh-pages/LICENSE)
*/
// Contact Form Scripts
$(function() {
$('.copyright').append(" " + new Date().getFullYear());
$("input,textarea").jqBootstrapValidation({
preventSubmit: true,
submitError: function($form, event, errors) {
// additional error messages or events
},
submitSuccess: function($form, event) {
event.preventDefault(); // prevent default submit behaviour
// get values from FORM
var name = $("input#name").val();
var email = $("input#email").val();
var phone = $("input#phone").val();
var message = $("textarea#message").val();
var firstName = name; // For Success/Failure Message
// Check for white space in name for Success/Fail message
if (firstName.indexOf(' ') >= 0) {
firstName = name.split(' ').slice(0, -1).join(' ');
}
$.ajax({
url: "././mail/contact_me.php",
type: "POST",
data: {
name: name,
phone: phone,
email: email,
message: message
},
cache: false,
success: function() {
// Success message
$('#success').html("<div class='alert alert-success'>");
$('#success > .alert-success').html("<button type='button' class='close' data-dismiss='alert' aria-hidden='true'>×")
.append("</button>");
$('#success > .alert-success')
.append("<strong>Your message has been sent. </strong>");
$('#success > .alert-success')
.append('</div>');
//clear all fields
$('#contactForm').trigger("reset");
},
error: function() {
// Fail message
$('#success').html("<div class='alert alert-danger'>");
$('#success > .alert-danger').html("<button type='button' class='close' data-dismiss='alert' aria-hidden='true'>×")
.append("</button>");
$('#success > .alert-danger').append("<strong>Sorry " + firstName + ", it seems that my mail server is not responding. Please try again later!");
$('#success > .alert-danger').append('</div>');
//clear all fields
$('#contactForm').trigger("reset");
},
})
},
filter: function() {
return $(this).is(":visible");
},
});
$("a[data-toggle=\"tab\"]").click(function(e) {
e.preventDefault();
$(this).tab("show");
});
});
/*When clicking on Full hide fail/success boxes */
$('#name').focus(function() {
$('#success').html('');
});
// jqBootstrapValidation
// * A plugin for automating validation on Twitter Bootstrap formatted forms.
// *
// * v1.3.6
// *
// * License: MIT <http://opensource.org/licenses/mit-license.php> - see LICENSE file
// *
// * http://ReactiveRaven.github.com/jqBootstrapValidation/
(function( $ ){
var createdElements = [];
var defaults = {
options: {
prependExistingHelpBlock: false,
sniffHtml: true, // sniff for 'required', 'maxlength', etc
preventSubmit: true, // stop the form submit event from firing if validation fails
submitError: false, // function called if there is an error when trying to submit
submitSuccess: false, // function called just before a successful submit event is sent to the server
semanticallyStrict: false, // set to true to tidy up generated HTML output
autoAdd: {
helpBlocks: true
},
filter: function () {
// return $(this).is(":visible"); // only validate elements you can see
return true; // validate everything
}
},
methods: {
init : function( options ) {
var settings = $.extend(true, {}, defaults);
settings.options = $.extend(true, settings.options, options);
var $siblingElements = this;
var uniqueForms = $.unique(
$siblingElements.map( function () {
return $(this).parents("form")[0];
}).toArray()
);
$(uniqueForms).bind("submit", function (e) {
var $form = $(this);
var warningsFound = 0;
var $inputs = $form.find("input,textarea,select").not("[type=submit],[type=image]").filter(settings.options.filter);
$inputs.trigger("submit.validation").trigger("validationLostFocus.validation");
$inputs.each(function (i, el) {
var $this = $(el),
$controlGroup = $this.parents(".form-group").first();
if (
$controlGroup.hasClass("warning")
) {
$controlGroup.removeClass("warning").addClass("error");
warningsFound++;
}
});
$inputs.trigger("validationLostFocus.validation");
if (warningsFound) {
if (settings.options.preventSubmit) {
e.preventDefault();
}
$form.addClass("error");
if ($.isFunction(settings.options.submitError)) {
settings.options.submitError($form, e, $inputs.jqBootstrapValidation("collectErrors", true));
}
} else {
$form.removeClass("error");
if ($.isFunction(settings.options.submitSuccess)) {
settings.options.submitSuccess($form, e);
}
}
});
return this.each(function(){
// Get references to everything we're interested in
var $this = $(this),
$controlGroup = $this.parents(".form-group").first(),
$helpBlock = $controlGroup.find(".help-block").first(),
$form = $this.parents("form").first(),
validatorNames = [];
// create message container if not exists
if (!$helpBlock.length && settings.options.autoAdd && settings.options.autoAdd.helpBlocks) {
$helpBlock = $('<div class="help-block" />');
$controlGroup.find('.controls').append($helpBlock);
createdElements.push($helpBlock[0]);
}
// =============================================================
// SNIFF HTML FOR VALIDATORS
// =============================================================
// *snort sniff snuffle*
if (settings.options.sniffHtml) {
var message = "";
// ---------------------------------------------------------
// PATTERN
// ---------------------------------------------------------
if ($this.attr("pattern") !== undefined) {
message = "Not in the expected format<!-- data-validation-pattern-message to override -->";
if ($this.data("validationPatternMessage")) {
message = $this.data("validationPatternMessage");
}
$this.data("validationPatternMessage", message);
$this.data("validationPatternRegex", $this.attr("pattern"));
}
// ---------------------------------------------------------
// MAX
// ---------------------------------------------------------
if ($this.attr("max") !== undefined || $this.attr("aria-valuemax") !== undefined) {
var max = ($this.attr("max") !== undefined ? $this.attr("max") : $this.attr("aria-valuemax"));
message = "Too high: Maximum of '" + max + "'<!-- data-validation-max-message to override -->";
if ($this.data("validationMaxMessage")) {
message = $this.data("validationMaxMessage");
}
$this.data("validationMaxMessage", message);
$this.data("validationMaxMax", max);
}
// ---------------------------------------------------------
// MIN
// ---------------------------------------------------------
if ($this.attr("min") !== undefined || $this.attr("aria-valuemin") !== undefined) {
var min = ($this.attr("min") !== undefined ? $this.attr("min") : $this.attr("aria-valuemin"));
message = "Too low: Minimum of '" + min + "'<!-- data-validation-min-message to override -->";
if ($this.data("validationMinMessage")) {
message = $this.data("validationMinMessage");
}
$this.data("validationMinMessage", message);
$this.data("validationMinMin", min);
}
// ---------------------------------------------------------
// MAXLENGTH
// ---------------------------------------------------------
if ($this.attr("maxlength") !== undefined) {
message = "Too long: Maximum of '" + $this.attr("maxlength") + "' characters<!-- data-validation-maxlength-message to override -->";
if ($this.data("validationMaxlengthMessage")) {
message = $this.data("validationMaxlengthMessage");
}
$this.data("validationMaxlengthMessage", message);
$this.data("validationMaxlengthMaxlength", $this.attr("maxlength"));
}
// ---------------------------------------------------------
// MINLENGTH
// ---------------------------------------------------------
if ($this.attr("minlength") !== undefined) {
message = "Too short: Minimum of '" + $this.attr("minlength") + "' characters<!-- data-validation-minlength-message to override -->";
if ($this.data("validationMinlengthMessage")) {
message = $this.data("validationMinlengthMessage");
}
$this.data("validationMinlengthMessage", message);
$this.data("validationMinlengthMinlength", $this.attr("minlength"));
}
// ---------------------------------------------------------
// REQUIRED
// ---------------------------------------------------------
if ($this.attr("required") !== undefined || $this.attr("aria-required") !== undefined) {
message = settings.builtInValidators.required.message;
if ($this.data("validationRequiredMessage")) {
message = $this.data("validationRequiredMessage");
}
$this.data("validationRequiredMessage", message);
}
// ---------------------------------------------------------
// NUMBER
// ---------------------------------------------------------
if ($this.attr("type") !== undefined && $this.attr("type").toLowerCase() === "number") {
message = settings.builtInValidators.number.message;
if ($this.data("validationNumberMessage")) {
message = $this.data("validationNumberMessage");
}
$this.data("validationNumberMessage", message);
}
// ---------------------------------------------------------
// EMAIL
// ---------------------------------------------------------
if ($this.attr("type") !== undefined && $this.attr("type").toLowerCase() === "email") {
message = "Not a valid email address<!-- data-validator-validemail-message to override -->";
if ($this.data("validationValidemailMessage")) {
message = $this.data("validationValidemailMessage");
} else if ($this.data("validationEmailMessage")) {
message = $this.data("validationEmailMessage");
}
$this.data("validationValidemailMessage", message);
}
// ---------------------------------------------------------
// MINCHECKED
// ---------------------------------------------------------
if ($this.attr("minchecked") !== undefined) {
message = "Not enough options checked; Minimum of '" + $this.attr("minchecked") + "' required<!-- data-validation-minchecked-message to override -->";
if ($this.data("validationMincheckedMessage")) {
message = $this.data("validationMincheckedMessage");
}
$this.data("validationMincheckedMessage", message);
$this.data("validationMincheckedMinchecked", $this.attr("minchecked"));
}
// ---------------------------------------------------------
// MAXCHECKED
// ---------------------------------------------------------
if ($this.attr("maxchecked") !== undefined) {
message = "Too many options checked; Maximum of '" + $this.attr("maxchecked") + "' required<!-- data-validation-maxchecked-message to override -->";
if ($this.data("validationMaxcheckedMessage")) {
message = $this.data("validationMaxcheckedMessage");
}
$this.data("validationMaxcheckedMessage", message);
$this.data("validationMaxcheckedMaxchecked", $this.attr("maxchecked"));
}
}
// =============================================================
// COLLECT VALIDATOR NAMES
// =============================================================
// Get named validators
if ($this.data("validation") !== undefined) {
validatorNames = $this.data("validation").split(",");
}
// Get extra ones defined on the element's data attributes
$.each($this.data(), function (i, el) {
var parts = i.replace(/([A-Z])/g, ",$1").split(",");
if (parts[0] === "validation" && parts[1]) {
validatorNames.push(parts[1]);
}
});
// =============================================================
// NORMALISE VALIDATOR NAMES
// =============================================================
var validatorNamesToInspect = validatorNames;
var newValidatorNamesToInspect = [];
do // repeatedly expand 'shortcut' validators into their real validators
{
// Uppercase only the first letter of each name
$.each(validatorNames, function (i, el) {
validatorNames[i] = formatValidatorName(el);
});
// Remove duplicate validator names
validatorNames = $.unique(validatorNames);
// Pull out the new validator names from each shortcut
newValidatorNamesToInspect = [];
$.each(validatorNamesToInspect, function(i, el) {
if ($this.data("validation" + el + "Shortcut") !== undefined) {
// Are these custom validators?
// Pull them out!
$.each($this.data("validation" + el + "Shortcut").split(","), function(i2, el2) {
newValidatorNamesToInspect.push(el2);
});
} else if (settings.builtInValidators[el.toLowerCase()]) {
// Is this a recognised built-in?
// Pull it out!
var validator = settings.builtInValidators[el.toLowerCase()];
if (validator.type.toLowerCase() === "shortcut") {
$.each(validator.shortcut.split(","), function (i, el) {
el = formatValidatorName(el);
newValidatorNamesToInspect.push(el);
validatorNames.push(el);
});
}
}
});
validatorNamesToInspect = newValidatorNamesToInspect;
} while (validatorNamesToInspect.length > 0)
// =============================================================
// SET UP VALIDATOR ARRAYS
// =============================================================
var validators = {};
$.each(validatorNames, function (i, el) {
// Set up the 'override' message
var message = $this.data("validation" + el + "Message");
var hasOverrideMessage = (message !== undefined);
var foundValidator = false;
message =
(
message
? message
: "'" + el + "' validation failed <!-- Add attribute 'data-validation-" + el.toLowerCase() + "-message' to input to change this message -->"
)
;
$.each(
settings.validatorTypes,
function (validatorType, validatorTemplate) {
if (validators[validatorType] === undefined) {
validators[validatorType] = [];
}
if (!foundValidator && $this.data("validation" + el + formatValidatorName(validatorTemplate.name)) !== undefined) {
validators[validatorType].push(
$.extend(
true,
{
name: formatValidatorName(validatorTemplate.name),
message: message
},
validatorTemplate.init($this, el)
)
);
foundValidator = true;
}
}
);
if (!foundValidator && settings.builtInValidators[el.toLowerCase()]) {
var validator = $.extend(true, {}, settings.builtInValidators[el.toLowerCase()]);
if (hasOverrideMessage) {
validator.message = message;
}
var validatorType = validator.type.toLowerCase();
if (validatorType === "shortcut") {
foundValidator = true;
} else {
$.each(
settings.validatorTypes,
function (validatorTemplateType, validatorTemplate) {
if (validators[validatorTemplateType] === undefined) {
validators[validatorTemplateType] = [];
}
if (!foundValidator && validatorType === validatorTemplateType.toLowerCase()) {
$this.data("validation" + el + formatValidatorName(validatorTemplate.name), validator[validatorTemplate.name.toLowerCase()]);
validators[validatorType].push(
$.extend(
validator,
validatorTemplate.init($this, el)
)
);
foundValidator = true;
}
}
);
}
}
if (! foundValidator) {
$.error("Cannot find validation info for '" + el + "'");
}
});
// =============================================================
// STORE FALLBACK VALUES
// =============================================================
$helpBlock.data(
"original-contents",
(
$helpBlock.data("original-contents")
? $helpBlock.data("original-contents")
: $helpBlock.html()
)
);
$helpBlock.data(
"original-role",
(
$helpBlock.data("original-role")
? $helpBlock.data("original-role")
: $helpBlock.attr("role")
)
);
$controlGroup.data(
"original-classes",
(
$controlGroup.data("original-clases")
? $controlGroup.data("original-classes")
: $controlGroup.attr("class")
)
);
$this.data(
"original-aria-invalid",
(
$this.data("original-aria-invalid")
? $this.data("original-aria-invalid")
: $this.attr("aria-invalid")
)
);
// =============================================================
// VALIDATION
// =============================================================
$this.bind(
"validation.validation",
function (event, params) {
var value = getValue($this);
// Get a list of the errors to apply
var errorsFound = [];
$.each(validators, function (validatorType, validatorTypeArray) {
if (value || value.length || (params && params.includeEmpty) || (!!settings.validatorTypes[validatorType].blockSubmit && params && !!params.submitting)) {
$.each(validatorTypeArray, function (i, validator) {
if (settings.validatorTypes[validatorType].validate($this, value, validator)) {
errorsFound.push(validator.message);
}
});
}
});
return errorsFound;
}
);
$this.bind(
"getValidators.validation",
function () {
return validators;
}
);
// =============================================================
// WATCH FOR CHANGES
// =============================================================
$this.bind(
"submit.validation",
function () {
return $this.triggerHandler("change.validation", {submitting: true});
}
);
$this.bind(
[
"keyup",
"focus",
"blur",
"click",
"keydown",
"keypress",
"change"
].join(".validation ") + ".validation",
function (e, params) {
var value = getValue($this);
var errorsFound = [];
$controlGroup.find("input,textarea,select").each(function (i, el) {
var oldCount = errorsFound.length;
$.each($(el).triggerHandler("validation.validation", params), function (j, message) {
errorsFound.push(message);
});
if (errorsFound.length > oldCount) {
$(el).attr("aria-invalid", "true");
} else {
var original = $this.data("original-aria-invalid");
$(el).attr("aria-invalid", (original !== undefined ? original : false));
}
});
$form.find("input,select,textarea").not($this).not("[name=\"" + $this.attr("name") + "\"]").trigger("validationLostFocus.validation");
errorsFound = $.unique(errorsFound.sort());
// Were there any errors?
if (errorsFound.length) {
// Better flag it up as a warning.
$controlGroup.removeClass("success error").addClass("warning");
// How many errors did we find?
if (settings.options.semanticallyStrict && errorsFound.length === 1) {
// Only one? Being strict? Just output it.
$helpBlock.html(errorsFound[0] +
( settings.options.prependExistingHelpBlock ? $helpBlock.data("original-contents") : "" ));
} else {
// Multiple? Being sloppy? Glue them together into an UL.
$helpBlock.html("<ul role=\"alert\"><li>" + errorsFound.join("</li><li>") + "</li></ul>" +
( settings.options.prependExistingHelpBlock ? $helpBlock.data("original-contents") : "" ));
}
} else {
$controlGroup.removeClass("warning error success");
if (value.length > 0) {
$controlGroup.addClass("success");
}
$helpBlock.html($helpBlock.data("original-contents"));
}
if (e.type === "blur") {
$controlGroup.removeClass("success");
}
}
);
$this.bind("validationLostFocus.validation", function () {
$controlGroup.removeClass("success");
});
});
},
destroy : function( ) {
return this.each(
function() {
var
$this = $(this),
$controlGroup = $this.parents(".form-group").first(),
$helpBlock = $controlGroup.find(".help-block").first();
// remove our events
$this.unbind('.validation'); // events are namespaced.
// reset help text
$helpBlock.html($helpBlock.data("original-contents"));
// reset classes
$controlGroup.attr("class", $controlGroup.data("original-classes"));
// reset aria
$this.attr("aria-invalid", $this.data("original-aria-invalid"));
// reset role
$helpBlock.attr("role", $this.data("original-role"));
// remove all elements we created
if (createdElements.indexOf($helpBlock[0]) > -1) {
$helpBlock.remove();
}
}
);
},
collectErrors : function(includeEmpty) {
var errorMessages = {};
this.each(function (i, el) {
var $el = $(el);
var name = $el.attr("name");
var errors = $el.triggerHandler("validation.validation", {includeEmpty: true});
errorMessages[name] = $.extend(true, errors, errorMessages[name]);
});
$.each(errorMessages, function (i, el) {
if (el.length === 0) {
delete errorMessages[i];
}
});
return errorMessages;
},
hasErrors: function() {
var errorMessages = [];
this.each(function (i, el) {
errorMessages = errorMessages.concat(
$(el).triggerHandler("getValidators.validation") ? $(el).triggerHandler("validation.validation", {submitting: true}) : []
);
});
return (errorMessages.length > 0);
},
override : function (newDefaults) {
defaults = $.extend(true, defaults, newDefaults);
}
},
validatorTypes: {
callback: {
name: "callback",
init: function ($this, name) {
return {
validatorName: name,
callback: $this.data("validation" + name + "Callback"),
lastValue: $this.val(),
lastValid: true,
lastFinished: true
};
},
validate: function ($this, value, validator) {
if (validator.lastValue === value && validator.lastFinished) {
return !validator.lastValid;
}
if (validator.lastFinished === true)
{
validator.lastValue = value;
validator.lastValid = true;
validator.lastFinished = false;
var rrjqbvValidator = validator;
var rrjqbvThis = $this;
executeFunctionByName(
validator.callback,
window,
$this,
value,
function (data) {
if (rrjqbvValidator.lastValue === data.value) {
rrjqbvValidator.lastValid = data.valid;
if (data.message) {
rrjqbvValidator.message = data.message;
}
rrjqbvValidator.lastFinished = true;
rrjqbvThis.data("validation" + rrjqbvValidator.validatorName + "Message", rrjqbvValidator.message);
// Timeout is set to avoid problems with the events being considered 'already fired'
setTimeout(function () {
rrjqbvThis.trigger("change.validation");
}, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
}
}
);
}
return false;
}
},
ajax: {
name: "ajax",
init: function ($this, name) {
return {
validatorName: name,
url: $this.data("validation" + name + "Ajax"),
lastValue: $this.val(),
lastValid: true,
lastFinished: true
};
},
validate: function ($this, value, validator) {
if (""+validator.lastValue === ""+value && validator.lastFinished === true) {
return validator.lastValid === false;
}
if (validator.lastFinished === true)
{
validator.lastValue = value;
validator.lastValid = true;
validator.lastFinished = false;
$.ajax({
url: validator.url,
data: "value=" + value + "&field=" + $this.attr("name"),
dataType: "json",
success: function (data) {
if (""+validator.lastValue === ""+data.value) {
validator.lastValid = !!(data.valid);
if (data.message) {
validator.message = data.message;
}
validator.lastFinished = true;
$this.data("validation" + validator.validatorName + "Message", validator.message);
// Timeout is set to avoid problems with the events being considered 'already fired'
setTimeout(function () {
$this.trigger("change.validation");
}, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
}
},
failure: function () {
validator.lastValid = true;
validator.message = "ajax call failed";
validator.lastFinished = true;
$this.data("validation" + validator.validatorName + "Message", validator.message);
// Timeout is set to avoid problems with the events being considered 'already fired'
setTimeout(function () {
$this.trigger("change.validation");
}, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
}
});
}
return false;
}
},
regex: {
name: "regex",
init: function ($this, name) {
return {regex: regexFromString($this.data("validation" + name + "Regex"))};
},
validate: function ($this, value, validator) {
return (!validator.regex.test(value) && ! validator.negative)
|| (validator.regex.test(value) && validator.negative);
}
},
required: {
name: "required",
init: function ($this, name) {
return {};
},
validate: function ($this, value, validator) {
return !!(value.length === 0 && ! validator.negative)
|| !!(value.length > 0 && validator.negative);
},
blockSubmit: true
},
match: {
name: "match",
init: function ($this, name) {
var element = $this.parents("form").first().find("[name=\"" + $this.data("validation" + name + "Match") + "\"]").first();
element.bind("validation.validation", function () {
$this.trigger("change.validation", {submitting: true});
});
return {"element": element};
},
validate: function ($this, value, validator) {
return (value !== validator.element.val() && ! validator.negative)
|| (value === validator.element.val() && validator.negative);
},
blockSubmit: true
},
max: {
name: "max",
init: function ($this, name) {
return {max: $this.data("validation" + name + "Max")};
},
validate: function ($this, value, validator) {
return (parseFloat(value, 10) > parseFloat(validator.max, 10) && ! validator.negative)
|| (parseFloat(value, 10) <= parseFloat(validator.max, 10) && validator.negative);
}
},
min: {
name: "min",
init: function ($this, name) {
return {min: $this.data("validation" + name + "Min")};
},
validate: function ($this, value, validator) {
return (parseFloat(value) < parseFloat(validator.min) && ! validator.negative)
|| (parseFloat(value) >= parseFloat(validator.min) && validator.negative);
}
},
maxlength: {
name: "maxlength",
init: function ($this, name) {
return {maxlength: $this.data("validation" + name + "Maxlength")};
},
validate: function ($this, value, validator) {
return ((value.length > validator.maxlength) && ! validator.negative)
|| ((value.length <= validator.maxlength) && validator.negative);
}
},
minlength: {
name: "minlength",
init: function ($this, name) {
return {minlength: $this.data("validation" + name + "Minlength")};
},
validate: function ($this, value, validator) {
return ((value.length < validator.minlength) && ! validator.negative)
|| ((value.length >= validator.minlength) && validator.negative);
}
},
maxchecked: {
name: "maxchecked",
init: function ($this, name) {
var elements = $this.parents("form").first().find("[name=\"" + $this.attr("name") + "\"]");
elements.bind("click.validation", function () {
$this.trigger("change.validation", {includeEmpty: true});
});
return {maxchecked: $this.data("validation" + name + "Maxchecked"), elements: elements};
},
validate: function ($this, value, validator) {
return (validator.elements.filter(":checked").length > validator.maxchecked && ! validator.negative)
|| (validator.elements.filter(":checked").length <= validator.maxchecked && validator.negative);
},
blockSubmit: true
},
minchecked: {
name: "minchecked",
init: function ($this, name) {
var elements = $this.parents("form").first().find("[name=\"" + $this.attr("name") + "\"]");
elements.bind("click.validation", function () {
$this.trigger("change.validation", {includeEmpty: true});
});
return {minchecked: $this.data("validation" + name + "Minchecked"), elements: elements};
},
validate: function ($this, value, validator) {
return (validator.elements.filter(":checked").length < validator.minchecked && ! validator.negative)
|| (validator.elements.filter(":checked").length >= validator.minchecked && validator.negative);
},
blockSubmit: true
}
},
builtInValidators: {
email: {
name: "Email",
type: "shortcut",
shortcut: "validemail"
},
validemail: {
name: "Validemail",
type: "regex",
regex: "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\.[A-Za-z]{2,4}",
message: "Not a valid email address<!-- data-validator-validemail-message to override -->"
},
passwordagain: {
name: "Passwordagain",
type: "match",
match: "password",
message: "Does not match the given password<!-- data-validator-paswordagain-message to override -->"
},
positive: {
name: "Positive",
type: "shortcut",
shortcut: "number,positivenumber"
},
negative: {
name: "Negative",
type: "shortcut",
shortcut: "number,negativenumber"
},
number: {
name: "Number",
type: "regex",
regex: "([+-]?\\\d+(\\\.\\\d*)?([eE][+-]?[0-9]+)?)?",
message: "Must be a number<!-- data-validator-number-message to override -->"
},
integer: {
name: "Integer",
type: "regex",
regex: "[+-]?\\\d+",
message: "No decimal places allowed<!-- data-validator-integer-message to override -->"
},
positivenumber: {
name: "Positivenumber",
type: "min",
min: 0,
message: "Must be a positive number<!-- data-validator-positivenumber-message to override -->"
},
negativenumber: {
name: "Negativenumber",
type: "max",
max: 0,
message: "Must be a negative number<!-- data-validator-negativenumber-message to override -->"
},
required: {
name: "Required",
type: "required",
message: "This is required<!-- data-validator-required-message to override -->"
},
checkone: {
name: "Checkone",
type: "minchecked",
minchecked: 1,
message: "Check at least one option<!-- data-validation-checkone-message to override -->"
}
}
};
var formatValidatorName = function (name) {
return name
.toLowerCase()
.replace(
/(^|\s)([a-z])/g ,
function(m,p1,p2) {
return p1+p2.toUpperCase();
}
)
;
};
var getValue = function ($this) {
// Extract the value we're talking about
var value = $this.val();
var type = $this.attr("type");
if (type === "checkbox") {
value = ($this.is(":checked") ? value : "");
}
if (type === "radio") {
value = ($('input[name="' + $this.attr("name") + '"]:checked').length > 0 ? value : "");
}
return value;
};
function regexFromString(inputstring) {
return new RegExp("^" + inputstring + "$");
}
/**
* Thanks to Jason Bunting via StackOverflow.com
*
* http://stackoverflow.com/questions/359788/how-to-execute-a-javascript-function-when-i-have-its-name-as-a-string#answer-359910
* Short link: http://tinyurl.com/executeFunctionByName
**/
function executeFunctionByName(functionName, context /*, args*/) {
var args = Array.prototype.slice.call(arguments).splice(2);
var namespaces = functionName.split(".");
var func = namespaces.pop();
for(var i = 0; i < namespaces.length; i++) {
context = context[namespaces[i]];
}
return context[func].apply(this, args);
}
$.fn.jqBootstrapValidation = function( method ) {
if ( defaults.methods[method] ) {
return defaults.methods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
} else if ( typeof method === 'object' || ! method ) {
return defaults.methods.init.apply( this, arguments );
} else {
$.error( 'Method ' + method + ' does not exist on jQuery.jqBootstrapValidation' );
return null;
}
};
$.jqBootstrapValidation = function (options) {
$(":input").not("[type=image],[type=submit]").jqBootstrapValidation.apply(this,arguments);
};
})( jQuery );
// Floating label headings for the contact form
$(function() {
$("body").on("input propertychange", ".floating-label-form-group", function(e) {
$(this).toggleClass("floating-label-form-group-with-value", !!$(e.target).val());
}).on("focus", ".floating-label-form-group", function() {
$(this).addClass("floating-label-form-group-with-focus");
}).on("blur", ".floating-label-form-group", function() {
$(this).removeClass("floating-label-form-group-with-focus");
});
});
// Navigation Scripts to Show Header on Scroll-Up
jQuery(document).ready(function($) {
var MQL = 1170;
//primary navigation slide-in effect
if ($(window).width() > MQL) {
var headerHeight = $('.navbar-custom').height();
$(window).on('scroll', {
previousTop: 0
},
function() {
var currentTop = $(window).scrollTop();
//check if user is scrolling up
if (currentTop < this.previousTop) {
//if scrolling up...
if (currentTop > 0 && $('.navbar-custom').hasClass('is-fixed')) {
$('.navbar-custom').addClass('is-visible');
} else {
$('.navbar-custom').removeClass('is-visible is-fixed');
}
} else {
//if scrolling down...
$('.navbar-custom').removeClass('is-visible');
if (currentTop > headerHeight && !$('.navbar-custom').hasClass('is-fixed')) $('.navbar-custom').addClass('is-fixed');
}
this.previousTop = currentTop;
});
}
});
|
var content = require('./content');
exports.json = function(obj) {
return JSON.stringify(obj);
};
exports.formatTrack = function(track, trackConfig) {
return trackConfig ? content.tracks.getName(track + '-' + trackConfig) : content.tracks.getName(track);
};
exports.formatCar = function(car) {
return content.cars.getName(car);
};
exports.formatTimestamp = function() {
this.tstamp = this.tstamp*1000;
var d = new Date(this.tstamp);
return d.toISOString().replace(/[T]/, ' ').split('.000').shift();
};
exports.if_eq = function(a, b, opts) {
if(a == b)
return opts.fn(this);
else
return opts.inverse(this);
};
exports.formatTime = function(timestr) {
var t = new Date(timestr);
return t.toTimeString().split(' (').shift();
};
exports.remainingTime = function(timestr, duration) {
var now = new Date();
var end = new Date(timestr);
end.setMinutes(end.getMinutes()+duration);
return ((end-now)/1000/60).toFixed(0);
};
|
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var async_1 = require('angular2/src/facade/async');
var lang_1 = require('angular2/src/facade/lang');
var pipe_1 = require('./pipe');
/**
* Implements async bindings to Observable.
*
* # Example
*
* In this example we bind the description observable to the DOM. The async pipe will convert an
*observable to the
* latest value it emitted. It will also request a change detection check when a new value is
*emitted.
*
* ```
* @Component({
* selector: "task-cmp",
* changeDetection: ON_PUSH
* })
* @View({
* template: "Task Description {{ description | async }}"
* })
* class Task {
* description:Observable<string>;
* }
*
* ```
*
* @exportedAs angular2/pipes
*/
var ObservablePipe = (function (_super) {
__extends(ObservablePipe, _super);
function ObservablePipe(_ref) {
_super.call(this);
this._ref = _ref;
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._observable = null;
}
ObservablePipe.prototype.supports = function (obs) { return async_1.ObservableWrapper.isObservable(obs); };
ObservablePipe.prototype.onDestroy = function () {
if (lang_1.isPresent(this._subscription)) {
this._dispose();
}
};
ObservablePipe.prototype.transform = function (obs) {
if (lang_1.isBlank(this._subscription)) {
this._subscribe(obs);
return null;
}
if (obs !== this._observable) {
this._dispose();
return this.transform(obs);
}
if (this._latestValue === this._latestReturnedValue) {
return this._latestReturnedValue;
}
else {
this._latestReturnedValue = this._latestValue;
return pipe_1.WrappedValue.wrap(this._latestValue);
}
};
ObservablePipe.prototype._subscribe = function (obs) {
var _this = this;
this._observable = obs;
this._subscription = async_1.ObservableWrapper.subscribe(obs, function (value) { _this._updateLatestValue(value); }, function (e) { throw e; });
};
ObservablePipe.prototype._dispose = function () {
async_1.ObservableWrapper.dispose(this._subscription);
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._observable = null;
};
ObservablePipe.prototype._updateLatestValue = function (value) {
this._latestValue = value;
this._ref.requestCheck();
};
return ObservablePipe;
})(pipe_1.Pipe);
exports.ObservablePipe = ObservablePipe;
/**
* Provides a factory for [ObervablePipe].
*
* @exportedAs angular2/pipes
*/
var ObservablePipeFactory = (function (_super) {
__extends(ObservablePipeFactory, _super);
function ObservablePipeFactory() {
_super.call(this);
}
ObservablePipeFactory.prototype.supports = function (obs) { return async_1.ObservableWrapper.isObservable(obs); };
ObservablePipeFactory.prototype.create = function (cdRef) { return new ObservablePipe(cdRef); };
ObservablePipeFactory = __decorate([
lang_1.CONST(),
__metadata('design:paramtypes', [])
], ObservablePipeFactory);
return ObservablePipeFactory;
})(pipe_1.PipeFactory);
exports.ObservablePipeFactory = ObservablePipeFactory;
exports.__esModule = true;
//# sourceMappingURL=observable_pipe.js.map
|
$(document).ready(function(){
$('img').each(function(){
//var maxwidth=$(this).parent(this).width();
if ($(this).parent("a").length == 0){
//if (this.width > maxwidth){
//this.width = maxwidth - 60;
$(this).wrap("<a rel='ignition' href="+this.src+" />");
//}
}else{
$(this).parent("a").attr("rel","ignition");
};
});
})
|
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @providesModule RelayRecordSourceProxy
* @flow
* @format
*/
'use strict';
const RelayModernRecord = require('RelayModernRecord');
const RelayRecordProxy = require('RelayRecordProxy');
const RelayRecordSourceSelectorProxy = require('RelayRecordSourceSelectorProxy');
const invariant = require('invariant');
const normalizeRelayPayload = require('normalizeRelayPayload');
const {EXISTENT, NONEXISTENT} = require('RelayRecordState');
const {ROOT_ID, ROOT_TYPE} = require('RelayStoreUtils');
import type {DataID} from '../util/RelayRuntimeTypes';
import type {HandlerProvider} from 'RelayDefaultHandlerProvider';
import type RelayRecordSourceMutator from 'RelayRecordSourceMutator';
import type {
HandleFieldPayload,
RecordSource,
RecordProxy,
RecordSourceProxy,
RecordSourceSelectorProxy,
OperationSelector,
} from 'RelayStoreTypes';
/**
* @internal
*
* A helper for manipulating a `RecordSource` via an imperative/OO-style API.
*/
class RelayRecordSourceProxy implements RecordSourceProxy {
_handlerProvider: ?HandlerProvider;
__mutator: RelayRecordSourceMutator;
_proxies: {[dataID: DataID]: ?RelayRecordProxy};
constructor(
mutator: RelayRecordSourceMutator,
handlerProvider?: ?HandlerProvider,
) {
this.__mutator = mutator;
this._handlerProvider = handlerProvider || null;
this._proxies = {};
}
publishSource(
source: RecordSource,
fieldPayloads?: ?Array<HandleFieldPayload>,
): void {
const dataIDs = source.getRecordIDs();
dataIDs.forEach(dataID => {
const status = source.getStatus(dataID);
if (status === EXISTENT) {
const sourceRecord = source.get(dataID);
if (sourceRecord) {
if (this.__mutator.getStatus(dataID) !== EXISTENT) {
this.create(dataID, RelayModernRecord.getType(sourceRecord));
}
this.__mutator.copyFieldsFromRecord(sourceRecord, dataID);
delete this._proxies[dataID];
}
} else if (status === NONEXISTENT) {
this.delete(dataID);
}
});
if (fieldPayloads && fieldPayloads.length) {
fieldPayloads.forEach(fieldPayload => {
const handler =
this._handlerProvider && this._handlerProvider(fieldPayload.handle);
invariant(
handler,
'RelayModernEnvironment: Expected a handler to be provided for handle `%s`.',
fieldPayload.handle,
);
handler.update(this, fieldPayload);
});
}
}
commitPayload(
operation: OperationSelector,
response: ?Object,
): RecordSourceSelectorProxy {
if (!response) {
return new RelayRecordSourceSelectorProxy(this, operation.fragment);
}
const {source, fieldPayloads} = normalizeRelayPayload(
operation.root,
response,
);
this.publishSource(source, fieldPayloads);
return new RelayRecordSourceSelectorProxy(this, operation.fragment);
}
create(dataID: DataID, typeName: string): RecordProxy {
this.__mutator.create(dataID, typeName);
delete this._proxies[dataID];
const record = this.get(dataID);
// For flow
invariant(
record,
'RelayRecordSourceProxy#create(): Expected the created record to exist.',
);
return record;
}
delete(dataID: DataID): void {
invariant(
dataID !== ROOT_ID,
'RelayRecordSourceProxy#delete(): Cannot delete the root record.',
);
delete this._proxies[dataID];
this.__mutator.delete(dataID);
}
get(dataID: DataID): ?RecordProxy {
if (!this._proxies.hasOwnProperty(dataID)) {
const status = this.__mutator.getStatus(dataID);
if (status === EXISTENT) {
this._proxies[dataID] = new RelayRecordProxy(
this,
this.__mutator,
dataID,
);
} else {
this._proxies[dataID] = status === NONEXISTENT ? null : undefined;
}
}
return this._proxies[dataID];
}
getRoot(): RecordProxy {
let root = this.get(ROOT_ID);
if (!root) {
root = this.create(ROOT_ID, ROOT_TYPE);
}
invariant(
root && root.getType() === ROOT_TYPE,
'RelayRecordSourceProxy#getRoot(): Expected the source to contain a ' +
'root record.',
);
return root;
}
}
module.exports = RelayRecordSourceProxy;
|
var test = require('tape');
var watch = require('../lib/navelgazer.js');
var path = require('path');
var fs = require('graceful-fs');
var touch = require('touch');
var fixtures = path.resolve(__dirname, 'fixtures');
// TODO: Ignoring this use case until Windows/OSX support confirmed
test('will detect change from modifying attributes', function(t) {
t.plan(2);
var expected = path.resolve(fixtures, 'one.js');
watch(expected, function(err, action, filepath) {
t.equal(action, 'change', 'action should have been changed when touched');
t.equal(expected, filepath, 'filepath should have matched expected when touched');
watch.closeAll();
t.end();
}, function() {
touch(expected, {atime:true,mtime:true});
})
});
|
import { NumberInput, LabelElement } from '../../libs/flow.module.js';
import { BaseNode } from '../core/BaseNode.js';
import { Vector3Node } from '../../renderers/nodes/Nodes.js';
export class Vector3Editor extends BaseNode {
constructor() {
const node = new Vector3Node();
super( 'Vector 3', 3, node, 325 );
const onUpdate = () => {
node.value.x = fieldX.getValue();
node.value.y = fieldY.getValue();
node.value.z = fieldZ.getValue();
};
const fieldX = new NumberInput().setTagColor( 'red' ).onChange( onUpdate );
const fieldY = new NumberInput().setTagColor( 'green' ).onChange( onUpdate );
const fieldZ = new NumberInput().setTagColor( 'blue' ).onChange( onUpdate );
this.add( new LabelElement( 'XYZ' ).add( fieldX ).add( fieldY ).add( fieldZ ) );
}
}
|
/*
* Copyright (c) 2012 Adobe Systems Incorporated. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
/*jslint vars: true, plusplus: true, devel: true, browser: true, nomen: true, indent: 4, maxerr: 50, regexp: true */
/*global define, $, brackets, jasmine, describe, it, expect, beforeEach, afterEach, waitsFor, waits, waitsForDone, runs */
define(function (require, exports, module) {
'use strict';
var Commands = require("command/Commands"),
FileUtils = require("file/FileUtils"),
Async = require("utils/Async"),
DocumentManager = require("document/DocumentManager"),
Editor = require("editor/Editor").Editor,
EditorManager = require("editor/EditorManager"),
FileSystemError = require("filesystem/FileSystemError"),
FileSystem = require("filesystem/FileSystem"),
PanelManager = require("view/PanelManager"),
ExtensionLoader = require("utils/ExtensionLoader"),
UrlParams = require("utils/UrlParams").UrlParams,
LanguageManager = require("language/LanguageManager"),
PreferencesBase = require("preferences/PreferencesBase");
var TEST_PREFERENCES_KEY = "com.adobe.brackets.test.preferences",
EDITOR_USE_TABS = false,
EDITOR_SPACE_UNITS = 4,
OPEN_TAG = "{{",
CLOSE_TAG = "}}",
RE_MARKER = /\{\{(\d+)\}\}/g,
absPathPrefix = (brackets.platform === "win" ? "c:/" : "/"),
_testSuites = {},
_testWindow,
_doLoadExtensions,
_rootSuite = { id: "__brackets__" },
_unitTestReporter;
function _getFileSystem() {
return _testWindow ? _testWindow.brackets.test.FileSystem : FileSystem;
}
/**
* Delete a path
* @param {string} fullPath
* @param {boolean=} silent Defaults to false. When true, ignores ERR_NOT_FOUND when deleting path.
* @return {$.Promise} Resolved when deletion complete, or rejected if an error occurs
*/
function deletePath(fullPath, silent) {
var result = new $.Deferred();
_getFileSystem().resolve(fullPath, function (err, item) {
if (!err) {
item.unlink(function (err) {
if (!err) {
result.resolve();
} else {
if (err === FileSystemError.NOT_FOUND && silent) {
result.resolve();
} else {
console.error("Unable to remove " + fullPath, err);
result.reject(err);
}
}
});
} else {
if (err === FileSystemError.NOT_FOUND && silent) {
result.resolve();
} else {
console.error("Unable to remove " + fullPath, err);
result.reject(err);
}
}
});
return result.promise();
}
/**
* Set permissions on a path
* @param {!string} path Path to change permissions on
* @param {!string} mode New mode as an octal string
* @return {$.Promise} Resolved when permissions are set or rejected if an error occurs
*/
function chmod(path, mode) {
var deferred = new $.Deferred();
brackets.fs.chmod(path, parseInt(mode, 8), function (err) {
if (err) {
deferred.reject(err);
} else {
deferred.resolve();
}
});
return deferred.promise();
}
function testDomain() {
return brackets.testing.nodeConnection.domains.testing;
}
/**
* Remove a directory (recursively) or file
*
* @param {!string} path Path to remove
* @return {$.Promise} Resolved when the path is removed, rejected if there was a problem
*/
function remove(path) {
return testDomain().remove(path);
}
/**
* Copy a directory (recursively) or file
*
* @param {!string} src Path to copy
* @param {!string} dest Destination directory
* @return {$.Promise} Resolved when the path is copied, rejected if there was a problem
*/
function copy(src, dest) {
return testDomain().copy(src, dest);
}
/**
* Resolves a path string to a File or Directory
* @param {!string} path Path to a file or directory
* @return {$.Promise} A promise resolved when the file/directory is found or
* rejected when any error occurs.
*/
function resolveNativeFileSystemPath(path) {
var result = new $.Deferred();
_getFileSystem().resolve(path, function (err, item) {
if (!err) {
result.resolve(item);
} else {
result.reject(err);
}
});
return result.promise();
}
/**
* Utility for tests that wait on a Promise to complete. Placed in the global namespace so it can be used
* similarly to the standard Jasmine waitsFor(). Unlike waitsFor(), must be called from INSIDE
* the runs() that generates the promise.
* @param {$.Promise} promise
* @param {string} operationName Name used for timeout error message
*/
window.waitsForDone = function (promise, operationName, timeout) {
timeout = timeout || 1000;
expect(promise).toBeTruthy();
promise.fail(function (err) {
expect("[" + operationName + "] promise rejected with: " + err).toBe("(expected resolved instead)");
});
waitsFor(function () {
return promise.state() === "resolved";
}, "success [" + operationName + "]", timeout);
};
/**
* Utility for tests that waits on a Promise to fail. Placed in the global namespace so it can be used
* similarly to the standards Jasmine waitsFor(). Unlike waitsFor(), must be called from INSIDE
* the runs() that generates the promise.
* @param {$.Promise} promise
* @param {string} operationName Name used for timeout error message
*/
window.waitsForFail = function (promise, operationName, timeout) {
timeout = timeout || 1000;
expect(promise).toBeTruthy();
promise.done(function (result) {
expect("[" + operationName + "] promise resolved with: " + result).toBe("(expected rejected instead)");
});
waitsFor(function () {
return promise.state() === "rejected";
}, "failure " + operationName, timeout);
};
/**
* Get or create a NativeFileSystem rooted at the system root.
* @return {$.Promise} A promise resolved when the native file system is found or rejected when an error occurs.
*/
function getRoot() {
var deferred = new $.Deferred();
resolveNativeFileSystemPath("/").then(deferred.resolve, deferred.reject);
return deferred.promise();
}
function getTestRoot() {
// /path/to/brackets/test/SpecRunner.html
var path = window.location.pathname;
path = path.substr(0, path.lastIndexOf("/"));
path = FileUtils.convertToNativePath(path);
return path;
}
function getTestPath(path) {
return getTestRoot() + path;
}
/**
* Get the temporary unit test project path. Use this path for unit tests that need to modify files on disk.
* @return {$.string} Path to the temporary unit test project
*/
function getTempDirectory() {
return getTestPath("/temp");
}
/**
* Create the temporary unit test project directory.
*/
function createTempDirectory() {
var deferred = new $.Deferred();
runs(function () {
var dir = _getFileSystem().getDirectoryForPath(getTempDirectory()).create(function (err) {
if (err && err !== FileSystemError.ALREADY_EXISTS) {
deferred.reject(err);
} else {
deferred.resolve();
}
});
});
waitsForDone(deferred, "Create temp directory", 500);
}
function _resetPermissionsOnSpecialTempFolders() {
var i,
folders = [],
baseDir = getTempDirectory(),
promise;
folders.push(baseDir + "/cant_read_here");
folders.push(baseDir + "/cant_write_here");
promise = Async.doSequentially(folders, function (folder) {
var deferred = new $.Deferred();
_getFileSystem().resolve(folder, function (err, entry) {
if (!err) {
// Change permissions if the directory exists
chmod(folder, "777").then(deferred.resolve, deferred.reject);
} else {
if (err === FileSystemError.NOT_FOUND) {
// Resolve the promise since the folder to reset doesn't exist
deferred.resolve();
} else {
deferred.reject();
}
}
});
return deferred.promise();
}, true);
return promise;
}
/**
* Remove temp folder used for temporary unit tests files
*/
function removeTempDirectory() {
var deferred = new $.Deferred(),
baseDir = getTempDirectory();
runs(function () {
_resetPermissionsOnSpecialTempFolders().done(function () {
deletePath(baseDir, true).then(deferred.resolve, deferred.reject);
}).fail(function () {
deferred.reject();
});
deferred.fail(function (err) {
console.log("boo");
});
waitsForDone(deferred.promise(), "removeTempDirectory", 1000);
});
}
function getBracketsSourceRoot() {
var path = window.location.pathname;
path = path.split("/");
path = path.slice(0, path.length - 2);
path.push("src");
return path.join("/");
}
/**
* Returns a Document suitable for use with an Editor in isolation, but that can be registered with
* DocumentManager via addRef() so it is maintained for global updates like name and language changes.
*
* Like a normal Document, if you cause an addRef() on this you MUST call releaseRef() later.
*
* @param {!{language:?string, filename:?string, content:?string }} options
* Language defaults to JavaScript, filename defaults to a placeholder name, and
* content defaults to "".
*/
function createMockActiveDocument(options) {
var language = options.language || LanguageManager.getLanguage("javascript"),
filename = options.filename || (absPathPrefix + "_unitTestDummyPath_/_dummyFile_" + Date.now() + "." + language._fileExtensions[0]),
content = options.content || "";
// Use unique filename to avoid collissions in open documents list
var dummyFile = _getFileSystem().getFileForPath(filename);
var docToShim = new DocumentManager.Document(dummyFile, new Date(), content);
// Prevent adding doc to working set
docToShim._handleEditorChange = function (event, editor, changeList) {
this.isDirty = !editor._codeMirror.isClean();
// TODO: This needs to be kept in sync with Document._handleEditorChange(). In the
// future, we should fix things so that we either don't need mock documents or that this
// is factored so it will just run in both.
$(this).triggerHandler("change", [this, changeList]);
};
docToShim.notifySaved = function () {
throw new Error("Cannot notifySaved() a unit-test dummy Document");
};
return docToShim;
}
/**
* Returns a Document suitable for use with an Editor in isolation: i.e., a Document that will
* never be set as the currentDocument or added to the working set.
*
* Unlike a real Document, does NOT need to be explicitly cleaned up.
*
* @param {string=} initialContent Defaults to ""
* @param {string=} languageId Defaults to JavaScript
*/
function createMockDocument(initialContent, languageId) {
var language = LanguageManager.getLanguage(languageId) || LanguageManager.getLanguage("javascript"),
options = { language: language, content: initialContent },
docToShim = createMockActiveDocument(options);
// Prevent adding doc to global 'open docs' list; prevents leaks or collisions if a test
// fails to clean up properly (if test fails, or due to an apparent bug with afterEach())
docToShim.addRef = function () {};
docToShim.releaseRef = function () {};
docToShim._ensureMasterEditor = function () {
if (!this._masterEditor) {
// Don't let Document create an Editor itself via EditorManager; the unit test can't clean that up
throw new Error("Use create/destroyMockEditor() to test edit operations");
}
};
return docToShim;
}
/**
* Returns a mock element (in the test runner window) that's offscreen, for
* parenting UI you want to unit-test. When done, make sure to delete it with
* remove().
* @return {jQueryObject} a jQuery object for an offscreen div
*/
function createMockElement() {
return $("<div/>")
.css({
position: "absolute",
left: "-10000px",
top: "-10000px"
})
.appendTo($("body"));
}
/**
* Returns an Editor tied to the given Document, but suitable for use in isolation
* (without being placed inside the surrounding Brackets UI). The Editor *will* be
* reported as the "active editor" by EditorManager.
*
* Must be cleaned up by calling destroyMockEditor(document) later.
*
* @param {!Document} doc
* @param {{startLine: number, endLine: number}=} visibleRange
* @return {!Editor}
*/
function createMockEditorForDocument(doc, visibleRange) {
// Initialize EditorManager/PanelManager and position the editor-holder offscreen
// (".content" may not exist, but that's ok for headless tests where editor height doesn't matter)
var $editorHolder = createMockElement().css("width", "1000px").attr("id", "mock-editor-holder");
PanelManager._setMockDOM($(".content"), $editorHolder);
EditorManager.setEditorHolder($editorHolder);
// create Editor instance
var editor = new Editor(doc, true, $editorHolder.get(0), visibleRange);
Editor.setUseTabChar(EDITOR_USE_TABS);
Editor.setSpaceUnits(EDITOR_SPACE_UNITS);
EditorManager._notifyActiveEditorChanged(editor);
return editor;
}
/**
* Returns a Document and Editor suitable for use in isolation: the Document
* will never be set as the currentDocument or added to the working set and the
* Editor does not live inside a full-blown Brackets UI layout. The Editor *will* be
* reported as the "active editor" by EditorManager, however.
*
* Must be cleaned up by calling destroyMockEditor(document) later.
*
* @param {string=} initialContent
* @param {string=} languageId
* @param {{startLine: number, endLine: number}=} visibleRange
* @return {!{doc:!Document, editor:!Editor}}
*/
function createMockEditor(initialContent, languageId, visibleRange) {
// create dummy Document, then Editor tied to it
var doc = createMockDocument(initialContent, languageId);
return { doc: doc, editor: createMockEditorForDocument(doc, visibleRange) };
}
/**
* Destroy the Editor instance for a given mock Document.
* @param {!Document} doc Document whose master editor to destroy
*/
function destroyMockEditor(doc) {
EditorManager._notifyActiveEditorChanged(null);
EditorManager._destroyEditorIfUnneeded(doc);
// Clear editor holder so EditorManager doesn't try to resize destroyed object
EditorManager.setEditorHolder(null);
$("#mock-editor-holder").remove();
}
/**
* Dismiss the currently open dialog as if the user had chosen the given button. Dialogs close
* asynchronously; after calling this, you need to start a new runs() block before testing the
* outcome. Also, in cases where asynchronous tasks are performed after the dialog closes,
* clients must also wait for any additional promises.
* @param {string} buttonId One of the Dialogs.DIALOG_BTN_* symbolic constants.
* @param {boolean=} enableFirst If true, then enable the button before clicking.
*/
function clickDialogButton(buttonId, enableFirst) {
// Make sure there's one and only one dialog open
var $dlg = _testWindow.$(".modal.instance"),
promise = $dlg.data("promise");
expect($dlg.length).toBe(1);
// Make sure desired button exists
var $dismissButton = $dlg.find(".dialog-button[data-button-id='" + buttonId + "']");
expect($dismissButton.length).toBe(1);
if (enableFirst) {
// Remove the disabled prop.
$dismissButton.prop("disabled", false);
}
// Click the button
$dismissButton.click();
// Dialog should resolve/reject the promise
waitsForDone(promise, "dismiss dialog");
}
function createTestWindowAndRun(spec, callback, options) {
runs(function () {
// Position popup windows in the lower right so they're out of the way
var testWindowWid = 1000,
testWindowHt = 700,
testWindowX = window.screen.availWidth - testWindowWid,
testWindowY = window.screen.availHeight - testWindowHt,
optionsStr = "left=" + testWindowX + ",top=" + testWindowY +
",width=" + testWindowWid + ",height=" + testWindowHt;
var params = new UrlParams();
// setup extension loading in the test window
params.put("extensions", _doLoadExtensions ?
"default,dev," + ExtensionLoader.getUserExtensionPath() :
"default");
// disable update check in test windows
params.put("skipUpdateCheck", true);
// disable loading of sample project
params.put("skipSampleProjectLoad", true);
// disable initial dialog for live development
params.put("skipLiveDevelopmentInfo", true);
// signals that main.js should configure RequireJS for tests
params.put("testEnvironment", true);
// option to launch test window with either native or HTML menus
if (options && options.hasOwnProperty("hasNativeMenus")) {
params.put("hasNativeMenus", (options.hasNativeMenus ? "true" : "false"));
}
_testWindow = window.open(getBracketsSourceRoot() + "/index.html?" + params.toString(), "_blank", optionsStr);
// Displays the primary console messages from the test window in the the
// test runner's console as well.
["log", "info", "warn", "error"].forEach(function (method) {
var originalMethod = _testWindow.console[method];
_testWindow.console[method] = function () {
var log = ["[testWindow] "].concat(Array.prototype.slice.call(arguments, 0));
console[method].apply(console, log);
originalMethod.apply(_testWindow.console, arguments);
};
});
_testWindow.isBracketsTestWindow = true;
_testWindow.executeCommand = function executeCommand(cmd, args) {
return _testWindow.brackets.test.CommandManager.execute(cmd, args);
};
_testWindow.closeAllFiles = function closeAllFiles() {
runs(function () {
var promise = _testWindow.executeCommand(_testWindow.brackets.test.Commands.FILE_CLOSE_ALL);
_testWindow.brackets.test.Dialogs.cancelModalDialogIfOpen(
_testWindow.brackets.test.DefaultDialogs.DIALOG_ID_SAVE_CLOSE,
_testWindow.brackets.test.DefaultDialogs.DIALOG_BTN_DONTSAVE
);
waitsForDone(promise, "Close all open files in working set");
});
};
});
// FIXME (issue #249): Need an event or something a little more reliable...
waitsFor(
function isBracketsDoneLoading() {
return _testWindow.brackets && _testWindow.brackets.test && _testWindow.brackets.test.doneLoading;
},
"brackets.test.doneLoading",
10000
);
runs(function () {
// callback allows specs to query the testWindow before they run
callback.call(spec, _testWindow);
});
}
function closeTestWindow() {
// debug-only to see testWindow state before closing
// waits(500);
runs(function () {
//we need to mark the documents as not dirty before we close
//or the window will stay open prompting to save
var openDocs = _testWindow.brackets.test.DocumentManager.getAllOpenDocuments();
openDocs.forEach(function resetDoc(doc) {
if (doc.isDirty) {
//just refresh it back to it's current text. This will mark it
//clean to save
doc.refreshText(doc.getText(), doc.diskTimestamp);
}
});
_testWindow.close();
_testWindow.executeCommand = null;
_testWindow = null;
});
}
function loadProjectInTestWindow(path) {
runs(function () {
// begin loading project path
var result = _testWindow.brackets.test.ProjectManager.openProject(path);
// wait for file system to finish loading
waitsForDone(result, "ProjectManager.openProject()", 10000);
});
}
/**
* Parses offsets from text offset markup (e.g. "{{1}}" for offset 1).
* @param {!string} text Text to parse
* @return {!{offsets:!Array.<{line:number, ch:number}>, text:!string, original:!string}}
*/
function parseOffsetsFromText(text) {
var offsets = [],
output = [],
i = 0,
line = 0,
charAt = 0,
ch = 0,
length = text.length,
exec = null,
found = false;
while (i < length) {
found = false;
if (text.slice(i, i + OPEN_TAG.length) === OPEN_TAG) {
// find "{{[0-9]+}}"
RE_MARKER.lastIndex = i;
exec = RE_MARKER.exec(text);
found = (exec !== null && exec.index === i);
if (found) {
// record offset info
offsets[exec[1]] = {line: line, ch: ch};
// advance
i += exec[0].length;
}
}
if (!found) {
charAt = text.substr(i, 1);
output.push(charAt);
if (charAt === '\n') {
line++;
ch = 0;
} else {
ch++;
}
i++;
}
}
return {offsets: offsets, text: output.join(""), original: text};
}
/**
* Creates absolute paths based on the test window's current project
* @param {!Array.<string>|string} paths Project relative file path(s) to convert. May pass a single string path or array.
* @return {!Array.<string>|string} Absolute file path(s)
*/
function makeAbsolute(paths) {
var fullPath = _testWindow.brackets.test.ProjectManager.getProjectRoot().fullPath;
function prefixProjectPath(path) {
if (path.indexOf(fullPath) === 0) {
return path;
}
return fullPath + path;
}
if (Array.isArray(paths)) {
return paths.map(prefixProjectPath);
} else {
return prefixProjectPath(paths);
}
}
/**
* Creates relative paths based on the test window's current project. Any paths,
* outside the project are included in the result, but left as absolute paths.
* @param {!Array.<string>|string} paths Absolute file path(s) to convert. May pass a single string path or array.
* @return {!Array.<string>|string} Relative file path(s)
*/
function makeRelative(paths) {
var fullPath = _testWindow.brackets.test.ProjectManager.getProjectRoot().fullPath,
fullPathLength = fullPath.length;
function removeProjectPath(path) {
if (path.indexOf(fullPath) === 0) {
return path.substring(fullPathLength);
}
return path;
}
if (Array.isArray(paths)) {
return paths.map(removeProjectPath);
} else {
return removeProjectPath(paths);
}
}
function makeArray(arg) {
if (!Array.isArray(arg)) {
return [arg];
}
return arg;
}
/**
* Parses offsets from a file using offset markup (e.g. "{{1}}" for offset 1).
* @param {!File} entry File to open
* @return {$.Promise} A promise resolved with a record that contains parsed offsets,
* the file text without offset markup, the original file content, and the corresponding
* file entry.
*/
function parseOffsetsFromFile(entry) {
var result = new $.Deferred();
FileUtils.readAsText(entry).done(function (text) {
var info = parseOffsetsFromText(text);
info.fileEntry = entry;
result.resolve(info);
}).fail(function (err) {
result.reject(err);
});
return result.promise();
}
/**
* Opens project relative file paths in the test window
* @param {!(Array.<string>|string)} paths Project relative file path(s) to open
* @return {!$.Promise} A promise resolved with a mapping of project-relative path
* keys to a corresponding Document
*/
function openProjectFiles(paths) {
var result = new $.Deferred(),
fullpaths = makeArray(makeAbsolute(paths)),
keys = makeArray(makeRelative(paths)),
docs = {},
FileViewController = _testWindow.brackets.test.FileViewController;
Async.doSequentially(fullpaths, function (path, i) {
var one = new $.Deferred();
FileViewController.addToWorkingSetAndSelect(path).done(function (doc) {
docs[keys[i]] = doc;
one.resolve();
}).fail(function (err) {
one.reject(err);
});
return one.promise();
}, false).done(function () {
result.resolve(docs);
}).fail(function (err) {
result.reject(err);
}).always(function () {
docs = null;
FileViewController = null;
});
return result.promise();
}
/**
* Create or overwrite a text file
* @param {!string} path Path for a file to be created/overwritten
* @param {!string} text Text content for the new file
* @param {!FileSystem} fileSystem FileSystem instance to use. Normally, use the instance from
* testWindow so the test copy of Brackets is aware of the newly-created file.
* @return {$.Promise} A promise resolved when the file is written or rejected when an error occurs.
*/
function createTextFile(path, text, fileSystem) {
var deferred = new $.Deferred(),
file = fileSystem.getFileForPath(path),
options = {
blind: true // overwriting previous files is OK
};
file.write(text, options, function (err) {
if (!err) {
deferred.resolve(file);
} else {
deferred.reject(err);
}
});
return deferred.promise();
}
/**
* Copy a file source path to a destination
* @param {!File} source Entry for the source file to copy
* @param {!string} destination Destination path to copy the source file
* @param {?{parseOffsets:boolean}} options parseOffsets allows optional
* offset markup parsing. File is written to the destination path
* without offsets. Offset data is passed to the doneCallbacks of the
* promise.
* @return {$.Promise} A promise resolved when the file is copied to the
* destination.
*/
function copyFileEntry(source, destination, options) {
options = options || {};
var deferred = new $.Deferred();
// read the source file
FileUtils.readAsText(source).done(function (text, modificationTime) {
getRoot().done(function (nfs) {
var offsets;
// optionally parse offsets
if (options.parseOffsets) {
var parseInfo = parseOffsetsFromText(text);
text = parseInfo.text;
offsets = parseInfo.offsets;
}
// create the new File
createTextFile(destination, text, _getFileSystem()).done(function (entry) {
deferred.resolve(entry, offsets, text);
}).fail(function (err) {
deferred.reject(err);
});
});
}).fail(function (err) {
deferred.reject(err);
});
return deferred.promise();
}
/**
* Copy a directory source to a destination
* @param {!Directory} source Directory to copy
* @param {!string} destination Destination path to copy the source directory to
* @param {?{parseOffsets:boolean, infos:Object, removePrefix:boolean}}} options
* parseOffsets - allows optional offset markup parsing. File is written to the
* destination path without offsets. Offset data is passed to the
* doneCallbacks of the promise.
* infos - an optional Object used when parseOffsets is true. Offset
* information is attached here, indexed by the file destination path.
* removePrefix - When parseOffsets is true, set removePrefix true
* to add a new key to the infos array that drops the destination
* path root.
* @return {$.Promise} A promise resolved when the directory and all it's
* contents are copied to the destination or rejected immediately
* upon the first error.
*/
function copyDirectoryEntry(source, destination, options) {
options = options || {};
options.infos = options.infos || {};
var parseOffsets = options.parseOffsets || false,
removePrefix = options.removePrefix || true,
deferred = new $.Deferred(),
destDir = _getFileSystem().getDirectoryForPath(destination);
// create the destination folder
destDir.create(function (err) {
if (err && err !== FileSystemError.ALREADY_EXISTS) {
deferred.reject();
return;
}
source.getContents(function (err, contents) {
if (!err) {
// copy all children of this directory
var copyChildrenPromise = Async.doInParallel(
contents,
function copyChild(child) {
var childDestination = destination + "/" + child.name,
promise;
if (child.isDirectory) {
promise = copyDirectoryEntry(child, childDestination, options);
} else {
promise = copyFileEntry(child, childDestination, options);
if (parseOffsets) {
// save offset data for each file path
promise.done(function (destinationEntry, offsets, text) {
options.infos[childDestination] = {
offsets : offsets,
fileEntry : destinationEntry,
text : text
};
});
}
}
return promise;
}
);
copyChildrenPromise.then(deferred.resolve, deferred.reject);
} else {
deferred.reject(err);
}
});
});
deferred.always(function () {
// remove destination path prefix
if (removePrefix && options.infos) {
var shortKey;
Object.keys(options.infos).forEach(function (key) {
shortKey = key.substr(destination.length + 1);
options.infos[shortKey] = options.infos[key];
});
}
});
return deferred.promise();
}
/**
* Copy a file or directory source path to a destination
* @param {!string} source Path for the source file or directory to copy
* @param {!string} destination Destination path to copy the source file or directory
* @param {?{parseOffsets:boolean, infos:Object, removePrefix:boolean}}} options
* parseOffsets - allows optional offset markup parsing. File is written to the
* destination path without offsets. Offset data is passed to the
* doneCallbacks of the promise.
* infos - an optional Object used when parseOffsets is true. Offset
* information is attached here, indexed by the file destination path.
* removePrefix - When parseOffsets is true, set removePrefix true
* to add a new key to the infos array that drops the destination
* path root.
* @return {$.Promise} A promise resolved when the directory and all it's
* contents are copied to the destination or rejected immediately
* upon the first error.
*/
function copyPath(source, destination, options) {
var deferred = new $.Deferred();
resolveNativeFileSystemPath(source).done(function (entry) {
var promise;
if (entry.isDirectory) {
promise = copyDirectoryEntry(entry, destination, options);
} else {
promise = copyFileEntry(entry, destination, options);
}
promise.then(deferred.resolve, function (err) {
console.error(destination);
deferred.reject();
});
}).fail(function () {
deferred.reject();
});
return deferred.promise();
}
/**
* Set editor cursor position to the given offset then activate an inline editor.
* @param {!Editor} editor
* @param {!{line:number, ch:number}} offset
* @return {$.Promise} a promise that will be resolved when an inline
* editor is created or rejected when no inline editors are available.
*/
function toggleQuickEditAtOffset(editor, offset) {
editor.setCursorPos(offset.line, offset.ch);
return _testWindow.executeCommand(Commands.TOGGLE_QUICK_EDIT);
}
/**
* Simulate key event. Found this code here:
* http://stackoverflow.com/questions/10455626/keydown-simulation-in-chrome-fires-normally-but-not-the-correct-key
*
* TODO: need parameter(s) for modifier keys
*
* @param {Number} key Key code
* @param (String) event Key event to simulate
* @param {HTMLElement} element Element to receive event
*/
function simulateKeyEvent(key, event, element) {
var doc = element.ownerDocument,
oEvent = doc.createEvent('KeyboardEvent');
if (event !== "keydown" && event !== "keyup" && event !== "keypress") {
console.log("SpecRunnerUtils.simulateKeyEvent() - unsupported keyevent: " + event);
return;
}
// Chromium Hack: need to override the 'which' property.
// Note: this code is not designed to work in IE, Safari,
// or other browsers. Well, maybe with Firefox. YMMV.
Object.defineProperty(oEvent, 'keyCode', {
get: function () {
return this.keyCodeVal;
}
});
Object.defineProperty(oEvent, 'which', {
get: function () {
return this.keyCodeVal;
}
});
Object.defineProperty(oEvent, 'charCode', {
get: function () {
return this.keyCodeVal;
}
});
if (oEvent.initKeyboardEvent) {
oEvent.initKeyboardEvent(event, true, true, doc.defaultView, key, 0, false, false, false, false);
} else {
oEvent.initKeyEvent(event, true, true, doc.defaultView, false, false, false, false, key, 0);
}
oEvent.keyCodeVal = key;
if (oEvent.keyCode !== key) {
console.log("keyCode mismatch " + oEvent.keyCode + "(" + oEvent.which + ")");
}
element.dispatchEvent(oEvent);
}
function getTestWindow() {
return _testWindow;
}
function setLoadExtensionsInTestWindow(doLoadExtensions) {
_doLoadExtensions = doLoadExtensions;
}
/**
* Change the size of an editor. The window size is not affected by this function.
* CodeMirror will change it's size withing Brackets.
*
* @param {!Editor} editor - instance of Editor
* @param {?number} width - the new width of the editor in pixel
* @param {?number} height - the new height of the editor in pixel
*/
function resizeEditor(editor, width, height) {
var oldSize = {};
if (editor) {
var jquery = editor.getRootElement().ownerDocument.defaultView.$,
$editorHolder = jquery('#editor-holder'),
$content = jquery('.content');
// preserve old size
oldSize.width = $editorHolder.width();
oldSize.height = $editorHolder.height();
if (width) {
$content.width(width);
$editorHolder.width(width);
editor.setSize(width, null); // Update CM size
}
if (height) {
$content.height(height);
$editorHolder.height(height);
editor.setSize(null, height); // Update CM size
}
editor.refreshAll(true); // update CM
}
return oldSize;
}
/**
* Extracts the jasmine.log() and/or jasmine.expect() messages from the given result,
* including stack traces if available.
* @param {Object} result A jasmine result item (from results.getItems()).
* @return {string} the error message from that item.
*/
function getResultMessage(result) {
var message;
if (result.type === 'log') {
message = result.toString();
} else if (result.type === 'expect' && result.passed && !result.passed()) {
message = result.message;
if (result.trace.stack) {
message = result.trace.stack;
}
}
return message;
}
/**
* Searches the DOM tree for text containing the given content. Useful for verifying
* that data you expect to show up in the UI somewhere is actually there.
*
* @param {jQueryObject|Node} root The root element to search from. Can be either a jQuery object
* or a raw DOM node.
* @param {string} content The content to find.
* @param {boolean} asLink If true, find the content in the href of an <a> tag, otherwise find it in text nodes.
* @return true if content was found
*/
function findDOMText(root, content, asLink) {
// Unfortunately, we can't just use jQuery's :contains() selector, because it appears that
// you can't escape quotes in it.
var i;
if (root.jquery) {
root = root.get(0);
}
if (!root) {
return false;
} else if (!asLink && root.nodeType === 3) { // text node
return root.textContent.indexOf(content) !== -1;
} else {
if (asLink && root.nodeType === 1 && root.tagName.toLowerCase() === "a" && root.getAttribute("href") === content) {
return true;
}
var children = root.childNodes;
for (i = 0; i < children.length; i++) {
if (findDOMText(children[i], content, asLink)) {
return true;
}
}
return false;
}
}
/**
* Counts the number of active specs in the current suite. Includes all
* descendants.
* @param {(jasmine.Suite|jasmine.Spec)} suiteOrSpec
* @return {number}
*/
function countSpecs(suiteOrSpec) {
var children = suiteOrSpec.children && typeof suiteOrSpec.children === "function" && suiteOrSpec.children();
if (Array.isArray(children)) {
var childCount = 0;
children.forEach(function (child) {
childCount += countSpecs(child);
});
return childCount;
}
if (jasmine.getEnv().specFilter(suiteOrSpec)) {
return 1;
}
return 0;
}
/**
* @private
* Adds a new before all or after all function to the current suite. If requires it creates a new
* object to store the before all and after all functions and a spec counter for the current suite.
* @param {string} type "beforeFirst" or "afterLast"
* @param {function} func The function to store
*/
function _addSuiteFunction(type, func) {
var suiteId = (jasmine.getEnv().currentSuite || _rootSuite).id;
if (!_testSuites[suiteId]) {
_testSuites[suiteId] = {
beforeFirst : [],
afterLast : [],
specCounter : null
};
}
_testSuites[suiteId][type].push(func);
}
/**
* Utility for tests that need to open a window or do something before every test in a suite
* @param {function} func
*/
window.beforeFirst = function (func) {
_addSuiteFunction("beforeFirst", func);
};
/**
* Utility for tests that need to close a window or do something after every test in a suite
* @param {function} func
*/
window.afterLast = function (func) {
_addSuiteFunction("afterLast", func);
};
/**
* @private
* Returns an array with the parent suites of the current spec with the top most suite last
* @return {Array.<jasmine.Suite>}
*/
function _getParentSuites() {
var suite = jasmine.getEnv().currentSpec.suite,
suites = [];
while (suite) {
suites.push(suite);
suite = suite.parentSuite;
}
return suites;
}
/**
* @private
* Calls each function in the given array of functions
* @param {Array.<function>} functions
*/
function _callFunctions(functions) {
var spec = jasmine.getEnv().currentSpec;
functions.forEach(function (func) {
func.apply(spec);
});
}
/**
* Calls the before first functions for the parent suites of the current spec when is the first spec of the suite.
*/
function runBeforeFirst() {
var suites = _getParentSuites().reverse();
// SpecRunner-scoped beforeFirst
if (_testSuites[_rootSuite.id].beforeFirst) {
_callFunctions(_testSuites[_rootSuite.id].beforeFirst);
_testSuites[_rootSuite.id].beforeFirst = null;
}
// Iterate through all the parent suites of the current spec
suites.forEach(function (suite) {
// If we have functions for this suite and it was never called, initialize the spec counter
if (_testSuites[suite.id] && _testSuites[suite.id].specCounter === null) {
_callFunctions(_testSuites[suite.id].beforeFirst);
_testSuites[suite.id].specCounter = countSpecs(suite);
}
});
}
/**
* @private
* @return {boolean} True if the current spect is the last spec to be run
*/
function _isLastSpec() {
return _unitTestReporter.activeSpecCompleteCount === _unitTestReporter.activeSpecCount - 1;
}
/**
* Calls the after last functions for the parent suites of the current spec when is the last spec of the suite.
*/
function runAfterLast() {
var suites = _getParentSuites();
// Iterate throught all the parent suites of the current spec
suites.forEach(function (suite) {
// If we have functions for this suite, reduce the spec counter
if (_testSuites[suite.id] && _testSuites[suite.id].specCounter > 0) {
_testSuites[suite.id].specCounter--;
// If this was the last spec of the suite run the after last functions and remove it
if (_testSuites[suite.id].specCounter === 0) {
_callFunctions(_testSuites[suite.id].afterLast);
delete _testSuites[suite.id];
}
}
});
// SpecRunner-scoped afterLast
if (_testSuites[_rootSuite.id].afterLast && _isLastSpec()) {
_callFunctions(_testSuites[_rootSuite.id].afterLast);
_testSuites[_rootSuite.id].afterLast = null;
}
}
// "global" custom matchers
beforeEach(function () {
this.addMatchers({
/**
* Expects the given editor's selection to be a cursor at the given position (no range selected)
*/
toHaveCursorPosition: function (line, ch) {
var editor = this.actual;
var selection = editor.getSelection();
var notString = this.isNot ? "not " : "";
var start = selection.start;
var end = selection.end;
var selectionMoreThanOneCharacter = start.line !== end.line || start.ch !== end.ch;
this.message = function () {
var message = "Expected the cursor to " + notString + "be at (" + line + ", " + ch +
") but it was actually at (" + start.line + ", " + start.ch + ")";
if (!this.isNot && selectionMoreThanOneCharacter) {
message += " and more than one character was selected.";
}
return message;
};
var positionsMatch = start.line === line && start.ch === ch;
// when adding the not operator, it's confusing to check both the size of the
// selection and the position. We just check the position in that case.
if (this.isNot) {
return positionsMatch;
} else {
return !selectionMoreThanOneCharacter && positionsMatch;
}
}
});
});
function setUnitTestReporter(reporter) {
_unitTestReporter = reporter;
}
exports.TEST_PREFERENCES_KEY = TEST_PREFERENCES_KEY;
exports.EDITOR_USE_TABS = EDITOR_USE_TABS;
exports.EDITOR_SPACE_UNITS = EDITOR_SPACE_UNITS;
exports.chmod = chmod;
exports.remove = remove;
exports.copy = copy;
exports.getTestRoot = getTestRoot;
exports.getTestPath = getTestPath;
exports.getTempDirectory = getTempDirectory;
exports.createTempDirectory = createTempDirectory;
exports.getBracketsSourceRoot = getBracketsSourceRoot;
exports.makeAbsolute = makeAbsolute;
exports.resolveNativeFileSystemPath = resolveNativeFileSystemPath;
exports.createMockDocument = createMockDocument;
exports.createMockActiveDocument = createMockActiveDocument;
exports.createMockElement = createMockElement;
exports.createMockEditorForDocument = createMockEditorForDocument;
exports.createMockEditor = createMockEditor;
exports.createTestWindowAndRun = createTestWindowAndRun;
exports.closeTestWindow = closeTestWindow;
exports.clickDialogButton = clickDialogButton;
exports.destroyMockEditor = destroyMockEditor;
exports.loadProjectInTestWindow = loadProjectInTestWindow;
exports.openProjectFiles = openProjectFiles;
exports.toggleQuickEditAtOffset = toggleQuickEditAtOffset;
exports.createTextFile = createTextFile;
exports.copyDirectoryEntry = copyDirectoryEntry;
exports.copyFileEntry = copyFileEntry;
exports.copyPath = copyPath;
exports.deletePath = deletePath;
exports.getTestWindow = getTestWindow;
exports.simulateKeyEvent = simulateKeyEvent;
exports.setLoadExtensionsInTestWindow = setLoadExtensionsInTestWindow;
exports.getResultMessage = getResultMessage;
exports.parseOffsetsFromText = parseOffsetsFromText;
exports.findDOMText = findDOMText;
exports.countSpecs = countSpecs;
exports.runBeforeFirst = runBeforeFirst;
exports.runAfterLast = runAfterLast;
exports.removeTempDirectory = removeTempDirectory;
exports.setUnitTestReporter = setUnitTestReporter;
exports.resizeEditor = resizeEditor;
});
|
!function(a) {
function c(a, b, c, d) {
var e = "categories" == b.xaxis.options.mode
, f = "categories" == b.yaxis.options.mode;
if (e || f) {
var g = d.format;
if (!g) {
var h = b;
if (g = [],
g.push({
x: !0,
number: !0,
required: !0
}),
g.push({
y: !0,
number: !0,
required: !0
}),
h.bars.show || h.lines.show && h.lines.fill) {
var i = !!(h.bars.show && h.bars.zero || h.lines.show && h.lines.zero);
g.push({
y: !0,
number: !0,
required: !1,
defaultValue: 0,
autoscale: i
}),
h.bars.horizontal && (delete g[g.length - 1].y,
g[g.length - 1].x = !0)
}
d.format = g
}
for (var j = 0; j < g.length; ++j)
g[j].x && e && (g[j].number = !1),
g[j].y && f && (g[j].number = !1)
}
}
function d(a) {
var b = -1;
for (var c in a)
a[c] > b && (b = a[c]);
return b + 1
}
function e(a) {
var b = [];
for (var c in a.categories) {
var d = a.categories[c];
d >= a.min && d <= a.max && b.push([d, c])
}
return b.sort(function(a, b) {
return a[0] - b[0]
}),
b
}
function f(b, c, d) {
if ("categories" == b[c].options.mode) {
if (!b[c].categories) {
var f = {}
, h = b[c].options.categories || {};
if (a.isArray(h))
for (var i = 0; i < h.length; ++i)
f[h[i]] = i;
else
for (var j in h)
f[j] = h[j];
b[c].categories = f
}
b[c].options.ticks || (b[c].options.ticks = e),
g(d, c, b[c].categories)
}
}
function g(a, b, c) {
for (var e = a.points, f = a.pointsize, g = a.format, h = b.charAt(0), i = d(c), j = 0; j < e.length; j += f)
if (null != e[j])
for (var k = 0; k < f; ++k) {
var l = e[j + k];
null != l && g[k][h] && (l in c || (c[l] = i,
++i),
e[j + k] = c[l])
}
}
function h(a, b, c) {
f(b, "xaxis", c),
f(b, "yaxis", c)
}
function i(a) {
a.hooks.processRawData.push(c),
a.hooks.processDatapoints.push(h)
}
var b = {
xaxis: {
categories: null
},
yaxis: {
categories: null
}
};
a.plot.plugins.push({
init: i,
options: b,
name: "categories",
version: "1.0"
})
}(jQuery);
|
define({
"_widgetLabel": "Pridėti duomenis",
"noOptionsConfigured": "Nesukonfigūruota nei viena parinktis.",
"tabs": {
"search": "Ieškoti",
"url": "URL",
"file": "Failas"
},
"search": {
"featureLayerTitlePattern": "{serviceName} - {layerName}",
"layerInaccessible": "Nepavyksta pasiekti sluoksnio.",
"loadError": "Pridėti duomenų, nepavyksta įkelti:",
"searchBox": {
"search": "Ieškoti",
"placeholder": "Ieškoti..."
},
"bboxOption": {
"bbox": "Žemėlapio ribose"
},
"scopeOptions": {
"anonymousContent": "Turinys",
"myContent": "Mano turinys",
"myOrganization": "Organizacija",
"curated": "Prižiūrima",
"ArcGISOnline": "ArcGIS Online"
},
"sortOptions": {
"prompt": "Rūšiuoti pagal:",
"relevance": "Aktualumas",
"title": "Pavadinimas",
"owner": "Savininkas",
"rating": "Vertinimas",
"views": "Peržiūros",
"date": "Data",
"switchOrder": "Pakeisti"
},
"typeOptions": {
"prompt": "Tipas",
"mapService": "Žemėlapių paslauga",
"featureService": "Elementų paslauga",
"imageService": "Vaizdų paslauga",
"vectorTileService": "Vektorių išklotinių paslauga",
"kml": "KML",
"wms": "WMS"
},
"resultsPane": {
"noMatch": "Rezultatų nėra."
},
"paging": {
"first": "<<",
"firstTip": "Pirmas",
"previous": "<",
"previousTip": "Ankstesnis",
"next": ">",
"nextTip": "Kitas",
"pagePattern": "{page}"
},
"resultCount": {
"countPattern": "{count} {type}",
"itemSingular": "Elementas",
"itemPlural": "Elementai (-ų)"
},
"item": {
"actions": {
"add": "Pridėti",
"close": "Uždaryti",
"remove": "Panaikinti",
"details": "Išsamiau",
"done": "Atlikta",
"editName": "Redaguoti pavadinimą"
},
"messages": {
"adding": "Pridedama...",
"removing": "Šalinama...",
"added": "Pridėta",
"addFailed": "Nepavyko pridėti",
"unsupported": "Nepalaikoma"
},
"typeByOwnerPattern": "{type}: {owner}",
"dateFormat": "yyyy MMMM dd",
"datePattern": "{date}",
"ratingsCommentsViewsPattern": "{ratings} {ratingsIcon} {comments} {commentsIcon} {views} {viewsIcon}",
"ratingsCommentsViewsLabels": {
"ratings": "vertinimai\", \"komentarai\": \"komentarai\", \"peržiūros\": \"peržiūros"
},
"types": {
"Map Service": "Žemėlapių paslauga",
"Feature Service": "Elementų paslauga",
"Image Service": "Vaizdų paslauga",
"Vector Tile Service": "Vektorių išklotinių paslauga",
"WMS": "WMS",
"KML": "KML"
}
}
},
"addFromUrl": {
"type": "Tipas",
"url": "URL",
"types": {
"ArcGIS": "ArcGIS Server internetinė paslauga",
"WMS": "WMS OGC internetinė paslauga",
"WMTS": "WMTS OGC internetinė paslauga",
"WFS": "WFS OGC internetinė paslauga",
"KML": "KML failas",
"GeoRSS": "GeoRSS failas",
"CSV": "CSV failas"
},
"samplesHint": "URL pavyzdys (-iai)"
},
"addFromFile": {
"intro": "Galite nuvilkti arba naršyti vieną iš šių failų tipų:",
"types": {
"Shapefile": "Shapefile failą (.zip, ZIP archyvą, kuriame yra visi Shapefile failai)",
"CSV": "CSV failą (.csv, su adresu arba platuma, ilguma, atskirtą kableliu, kabliataškiu arba tabuliavimo žyme)",
"GPX": "GPX failą (.gpx, GPS Exchange formato)",
"GeoJSON": "GeoJSON failą (.geo.json arba .geojson)"
},
"generalizeOn": "Atvaizdavimui internete supaprastinkite objektų geometriją",
"dropOrBrowse": "Nuvilkti arba naršyti",
"browse": "Parinkti",
"invalidType": "Šis failo tipas nepalaikomas.",
"addingPattern": "{filename}: pridedama...",
"addFailedPattern": "{filename}: pridėti nepavyko",
"featureCountPattern": "{filename}: {count} elementai (-ų)",
"invalidTypePattern": "{filename}: šis paslaugos tipas nepalaikomas",
"maxFeaturesAllowedPattern": "Leidžiama daugiausiai tiek elementų: {count}",
"layerNamePattern": "{filename} – {name}"
},
"layerList": {
"caption": "Sluoksniai",
"noLayersAdded": "Nepridėtas nė vienas sluoksnis.",
"removeLayer": "Pašalinti sluoksnį",
"back": "Atgal"
}
});
|
/**
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Mickael Jeanroy
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
require('@babel/register')({
ignore: [
/node_modules/,
],
});
const gulp = require('gulp');
const clean = require('./scripts/clean');
const lint = require('./scripts/lint');
const build = require('./scripts/build');
const test = require('./scripts/test');
const release = require('./scripts/release');
const changelog = require('./scripts/changelog');
const prebuild = gulp.series(clean, lint);
const pretest = gulp.series(prebuild, build);
const prerelease = gulp.series(pretest, test.test);
module.exports = {
'clean': clean,
'lint': lint,
'build': gulp.series(prebuild, build),
'tdd': gulp.series(pretest, test.tdd),
'test': gulp.series(pretest, test.test),
'release:patch': gulp.series(prerelease, release.patch),
'release:minor': gulp.series(prerelease, release.minor),
'release:major': gulp.series(prerelease, release.major),
'changelog': changelog,
};
|
export default (() => {
let o;
return [
{
['offset']: 12368,
['dst']: false,
['abbrev']: 'LMT',
['until']: -1577935568,
['format']: 'LMT',
},
{
['offset']: 14400,
['dst']: false,
['abbrev']: '+04',
['until']: 76190400,
['format']: '+04',
},
{
['offset']: 10800,
['dst']: false,
['abbrev']: '+03',
['until']: Infinity,
['format']: '+03',
},
];
})();
;
|
/* globals require describe it beforeEach afterEach*/
const chai = require("chai");
const sinonModule = require("sinon");
const mocks = require("./utils/mocks");
let expect = chai.expect;
const superheroes = [{
_id: 1,
name: "Batman",
secretIdentity: "Bruce wayne"
}];
describe("Test superheroes controller", () => {
let sinon;
let data = {
getSuperheroes: () => {},
getSuperheroById: id => {},
createSuperhero: () => {}
};
beforeEach(() => {
sinon = sinonModule.sandbox.create();
sinon.stub(data, "getSuperheroes", () => {
let count = superheroes.length;
return Promise.resolve({ superheroes, count });
});
sinon.stub(data, "getSuperheroById", id => {
let superhero = superheroes.find(sh => sh._id === Number(id));
return Promise.resolve(superhero || null);
});
sinon.stub(data, "createSuperhero", () => {
});
});
afterEach(() => {
sinon.restore();
});
describe("getSuperheroes", () => {
it("expect to work", done => {
let controller = require("../../controllers/superheroes-controller")({ data });
let req = mocks.createRequest();
let res = mocks.createResponse();
res.on("end", () => {
expect(res.params.model.model).eqls(superheroes);
done();
});
controller.getSuperheroes(req, res);
});
it("expect to work", done => {
let controller = require("../../controllers/superheroes-controller")({ data });
let req = mocks.createRequest();
let res = mocks.createResponse();
res.on("end", () => {
expect(res.params.model.model).eqls(superheroes);
done();
});
controller.getSuperheroes(req, res);
});
});
});
|
/**
* ESUI (Enterprise Simple UI library)
* Copyright 2013 Baidu Inc. All rights reserved.
*
* @ignore
* @file 字符串相关基础库
* @author otakustay
*/
define(
function (require) {
var u = require('underscore');
/**
* @override lib
*/
var lib = {};
var WHITESPACE = /^[\s\xa0\u3000]+|[\u3000\xa0\s]+$/g;
/**
* 删除目标字符串两端的空白字符
*
* @param {string} source 目标字符串
* @return {string} 删除两端空白字符后的字符串
*/
lib.trim = function (source) {
if (!source) {
return '';
}
return String(source).replace(WHITESPACE, '');
};
/**
* 字符串格式化
*
* 简单的格式化使用`${name}`进行占位
*
* @param {string} template 原字符串
* @param {Object} data 用于模板替换的数据
* @return {string} 格式化后的字符串
*/
lib.format = function (template, data) {
if (!template) {
return '';
}
if (data == null) {
return template;
}
return template.replace(
/\$\{(.+?)\}/g,
function (match, key) {
var replacer = data[key];
if (typeof replacer === 'function') {
replacer = replacer(key);
}
return replacer == null ? '' : replacer;
}
);
};
/**
* 将字符串转换成`camelCase`格式
*
* 该方法将横线`-`视为单词的 **唯一分隔符**
*
* @param {string} source 源字符串
* @return {string}
*/
lib.camelize = function (source) {
if (!source) {
return '';
}
return source.replace(
/-([a-z])/g,
function (alpha) {
return alpha.toUpperCase();
}
);
};
/**
* 将字符串转换成`PascalCase`格式
*
* 该方法将横线`-`视为单词的 **唯一分隔符**
*
* @param {string} source 源字符串
* @return {string}
*/
lib.pascalize = function (source) {
if (!source) {
return '';
}
return source.charAt(0).toUpperCase()
+ lib.camelize(source.slice(1));
};
/**
* 将Token列表字符串切分为数组
*
* Token列表是使用逗号或空格分隔的字符串
*
* @param {string | string[] | null | undefined} input 输入值
* @return {string[]}
*/
lib.splitTokenList = function (input) {
if (!input) {
return [];
}
if (u.isArray(input)) {
return;
}
return u.chain(input.split(/[,\s]/))
.map(lib.trim)
.compact()
.value();
};
return lib;
}
);
|
// Copyright IBM Corp. 2015. All Rights Reserved.
// Node module: loopback-getting-started-intermediate
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT
module.exports = function(Review) {
Review.beforeRemote('create', function(context, user, next) {
context.args.data.date = Date.now();
context.args.data.publisherId = context.req.accessToken.userId;
next();
});
};
|
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon( /*#__PURE__*/_jsx("path", {
d: "M15 7.5V2H9v5.5l3 3 3-3zM7.5 9H2v6h5.5l3-3-3-3zM9 16.5V22h6v-5.5l-3-3-3 3zM16.5 9l-3 3 3 3H22V9h-5.5z"
}), 'GamesSharp');
|
import { getInstance } from '../../utils'
import { sendAndReactToTransaction } from '../transaction/asyncActions'
import { receiveConcepts } from './actions'
import { receiveVariable } from '../web3/actions'
export function loadConceptsFromConceptRegistery (currentBlock) {
return async (dispatch, getState) => {
const conceptRegistryInstance = getInstance.conceptRegistry(getState())
// get concepts from registry
let pastevents = await conceptRegistryInstance.getPastEvents('ConceptCreation', {
fromBlock: getState().ethereum.conceptsLastUpdatedAt,
toBlock: currentBlock
})
let concepts = {}
await Promise.all(pastevents.map(async (event) => {
let conceptAddress = event.returnValues._concept
// get concept data
let decodedConceptData = await getDecodedConceptData(conceptAddress)(dispatch, getState)
return (concepts[conceptAddress] = decodedConceptData)
}))
dispatch(receiveConcepts(concepts))
// We now kno that our concept data is up to date until currentBlock
// only updated if pastevents are not an empty object, since infura soemtimes sends an empty object
if (pastevents.length > 0) { dispatch(receiveVariable('conceptsLastUpdatedAt', currentBlock)) }
return concepts
}
}
// get the concept data and decode it
export function getDecodedConceptData (conceptAddress) {
return async (dispatch, getState) => {
// instanciate Concept Contract to get 'data' (ie the name of the concept)
let conceptInstance = getInstance.concept(getState(), conceptAddress)
// get and decode data to retrieve ipfs hash, else keep the string
let decodedConceptDataHash, decodedConceptData
let hash = await conceptInstance.methods.data().call()
decodedConceptDataHash = hash ? Buffer.from(hash.slice(2), 'hex').toString('utf8') : 'No concept data hash'
// retrieve JSON from IPFS if the data is an IPFS hash
if (decodedConceptDataHash.substring(0, 2) === 'Qm') {
// setup ipfs api
const ipfsAPI = require('ipfs-api')
const ipfs = ipfsAPI('ipfs.infura.io', '5001', {protocol: 'https'})
// verify that description is correctly stord and log it
let resp = await ipfs.get(decodedConceptDataHash)
decodedConceptData = resp[0].content.toString()
// parse JSON
decodedConceptData = JSON.parse(decodedConceptData)
} else {
// if no ipfs hash, just use data string decodedConceptDataHash
decodedConceptData = {
name: decodedConceptDataHash,
description: decodedConceptDataHash
}
}
return decodedConceptData
}
}
// combination of two functions above for directly creating assessments from conceptList
export function loadConceptContractAndCreateAssessment (conceptAddress, cost, callbacks) {
return async (dispatch, getState) => {
let userAddress = getState().ethereum.userAddress
let conceptInstance = getInstance.concept(getState(), conceptAddress)
const size = 5
const endTime = 7 * 24 * 3600
const startTime = 3 * 24 * 3600
sendAndReactToTransaction(
dispatch,
() => {
return conceptInstance.methods.makeAssessment(
cost * 1e9, size, startTime, endTime
).send({from: userAddress})
},
'makeAssessment',
userAddress,
conceptAddress,
callbacks
)
}
}
// estimate the gas of the transaction above
export function estimateAssessmentCreationGasCost (conceptAddress, cost, callBack) {
return async (dispatch, getState) => {
// instanciate Concept Contract
let userAddress = getState().ethereum.userAddress
let conceptInstance = getInstance.concept(getState(), conceptAddress)
const size = 5
const endTime = 7 * 24 * 3600
const startTime = 3 * 24 * 3600
// use estimateGas to get transaction gas cost before it is published
let estimate = await conceptInstance.methods.makeAssessment(cost * 1e9, size, startTime, endTime).estimateGas({from: userAddress, gas: 3000000})
// then get current gasPrice
let gasPrice = await getState().ethereum.web3.eth.getGasPrice()
// then convert it to eth from wei and multiply it by the estimate
callBack(estimate * getState().ethereum.web3.utils.fromWei(gasPrice.toString(), 'ether'))
}
}
|
hljs.registerLanguage("java",function(){"use strict";return function(e){
var n="false synchronized int abstract float private char boolean var static null if const for true while long strictfp finally protected import native final void enum else break transient catch instanceof byte super volatile case assert short package default double public try this switch continue throws protected public private module requires exports do",a={
className:"meta",begin:"@[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*",
contains:[{begin:/\(/,end:/\)/,contains:["self"]}]
},s="\\.([0-9](_*[0-9])*)",i="[0-9a-fA-F](_*[0-9a-fA-F])*",r={
className:"number",variants:[{
begin:`(\\b([0-9](_*[0-9])*)((${s})|\\.)?|(${s}))[eE][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
},{begin:`\\b([0-9](_*[0-9])*)((${s})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{
begin:`(${s})[fFdD]?\\b`},{begin:"\\b([0-9](_*[0-9])*)[fFdD]\\b"},{
begin:`\\b0[xX]((${i})\\.?|(${i})?\\.(${i}))[pP][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${i})[lL]?\\b`},{
begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],
relevance:0};return{name:"Java",aliases:["jsp"],keywords:n,illegal:/<\/|#/,
contains:[e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,
relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]
}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{
className:"class",beginKeywords:"class interface enum",end:/[{;=]/,
excludeEnd:!0,keywords:"class interface enum",illegal:/[:"\[\]]/,contains:[{
beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},{
beginKeywords:"new throw return else",relevance:0},{className:"class",
begin:"record\\s+"+e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,excludeEnd:!0,
end:/[{;=]/,keywords:n,contains:[{beginKeywords:"record"},{
begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,
contains:[e.UNDERSCORE_TITLE_MODE]},{className:"params",begin:/\(/,end:/\)/,
keywords:n,relevance:0,contains:[e.C_BLOCK_COMMENT_MODE]
},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"function",
begin:"([\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*(<[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*(\\s*,\\s*[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*)*>)?\\s+)+"+e.UNDERSCORE_IDENT_RE+"\\s*\\(",
returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:n,contains:[{
begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,
contains:[e.UNDERSCORE_TITLE_MODE]},{className:"params",begin:/\(/,end:/\)/,
keywords:n,relevance:0,
contains:[a,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,r,e.C_BLOCK_COMMENT_MODE]
},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},r,a]}}}());
|
define({
"instruction": "Selecione e configure camadas que serão mostradas na Tabela de Atributos inicialmente.",
"label": "Camada",
"show": "Mostrar",
"actions": "Configurar campos de camada",
"field": "Campo",
"alias": "Nome Alternativo",
"visible": "Visível",
"linkField": "Campo de vínculo",
"noLayers": "Nenhuma camada de feição está disponível",
"back": "Voltar",
"exportCSV": "Permitir exportação para CSV",
"expand": "Expandir inicialmente o widget",
"filterByExtent": "Habilitar Filtrar por Extensão de Mapa por padrão",
"restore": "Restaurar para valor padrão",
"ok": "OK",
"cancel": "Cancelar",
"includePoint": "Inlcuir coordenadas de ponto no arquivo exportado",
"configureLayerFields": "Configurar Campos da Camada",
"result": "Salvo com sucesso",
"warning": "Selecione a primeira opção de Mostrar.",
"fieldCheckWarning": "Pelo menos um campo deve ser selecionado.",
"unsupportQueryWarning": "A camada precisa suportar a operação de consulta para aparecer no widget da Tabela de Atributo. Certifique-se que o recurso de consulta no serviço está ativado.",
"unsupportQueryLayers": "A seguinte camada precisa suportar a operação de consulta para aparecer no widget da Tabela de Atributo. Certifique-se que o recurso de consulta no serviço está ativado.",
"fieldName": "Nome",
"fieldAlias": "Nome Alternativo",
"fieldVisibility": "Visibilidade",
"fieldActions": "Ações",
"showAttachments": "Mostrar anexos"
});
|
import r from 'restructure';
import Entity from '../entity';
export default Entity({
raceID: r.uint8,
classID: r.uint8,
});
|
/* */
define(['exports', 'core-js', 'aurelia-logging', 'aurelia-metadata', 'aurelia-dependency-injection', 'aurelia-loader', 'aurelia-path', 'aurelia-templating', 'aurelia-binding', 'aurelia-task-queue'], function (exports, _coreJs, _aureliaLogging, _aureliaMetadata, _aureliaDependencyInjection, _aureliaLoader, _aureliaPath, _aureliaTemplating, _aureliaBinding, _aureliaTaskQueue) {
'use strict';
exports.__esModule = true;
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
var _core = _interopRequireDefault(_coreJs);
var logger = _aureliaLogging.getLogger('aurelia');
function loadPlugin(aurelia, loader, info) {
logger.debug('Loading plugin ' + info.moduleId + '.');
aurelia.currentPluginId = info.moduleId.endsWith('.js') || info.moduleId.endsWith('.ts') ? info.moduleId.substring(0, info.moduleId.length - 3) : info.moduleId;
return loader.loadModule(info.moduleId).then(function (m) {
if ('configure' in m) {
return Promise.resolve(m.configure(aurelia, info.config || {})).then(function () {
aurelia.currentPluginId = null;
logger.debug('Configured plugin ' + info.moduleId + '.');
});
} else {
aurelia.currentPluginId = null;
logger.debug('Loaded plugin ' + info.moduleId + '.');
}
});
}
var Plugins = (function () {
function Plugins(aurelia) {
_classCallCheck(this, Plugins);
this.aurelia = aurelia;
this.info = [];
this.processed = false;
}
Plugins.prototype.plugin = function plugin(moduleId, config) {
var plugin = { moduleId: moduleId, config: config || {} };
if (this.processed) {
loadPlugin(this.aurelia, this.aurelia.loader, plugin);
} else {
this.info.push(plugin);
}
return this;
};
Plugins.prototype._process = function _process() {
var _this = this;
var aurelia = this.aurelia,
loader = aurelia.loader,
info = this.info,
current;
if (this.processed) {
return;
}
var next = function next() {
if (current = info.shift()) {
return loadPlugin(aurelia, loader, current).then(next);
}
_this.processed = true;
return Promise.resolve();
};
return next();
};
return Plugins;
})();
exports.Plugins = Plugins;
var logger = _aureliaLogging.getLogger('aurelia'),
slice = Array.prototype.slice;
if (!window.CustomEvent || typeof window.CustomEvent !== 'function') {
var CustomEvent = function CustomEvent(event, params) {
var params = params || {
bubbles: false,
cancelable: false,
detail: undefined
};
var evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
return evt;
};
CustomEvent.prototype = window.Event.prototype;
window.CustomEvent = CustomEvent;
}
function preventActionlessFormSubmit() {
document.body.addEventListener('submit', function (evt) {
var target = evt.target;
var action = target.action;
if (target.tagName.toLowerCase() === 'form' && !action) {
evt.preventDefault();
}
});
}
function loadResources(container, resourcesToLoad, appResources) {
var viewEngine = container.get(_aureliaTemplating.ViewEngine),
importIds = Object.keys(resourcesToLoad),
names = new Array(importIds.length),
i,
ii;
for (i = 0, ii = importIds.length; i < ii; ++i) {
names[i] = resourcesToLoad[importIds[i]];
}
return viewEngine.importViewResources(importIds, names, appResources);
}
var Aurelia = (function () {
function Aurelia(loader, container, resources) {
_classCallCheck(this, Aurelia);
this.loader = loader || new window.AureliaLoader();
this.container = container || new _aureliaDependencyInjection.Container();
this.resources = resources || new _aureliaTemplating.ResourceRegistry();
this.use = new Plugins(this);
this.resourcesToLoad = {};
this.withInstance(Aurelia, this);
this.withInstance(_aureliaLoader.Loader, this.loader);
this.withInstance(_aureliaTemplating.ResourceRegistry, this.resources);
this.container.makeGlobal();
}
Aurelia.prototype.withInstance = function withInstance(type, instance) {
this.container.registerInstance(type, instance);
return this;
};
Aurelia.prototype.withSingleton = function withSingleton(type, implementation) {
this.container.registerSingleton(type, implementation);
return this;
};
Aurelia.prototype.globalizeResources = function globalizeResources(resources) {
var toAdd = Array.isArray(resources) ? resources : arguments,
i,
ii,
resource,
pluginPath = this.currentPluginId || '',
path,
internalPlugin = pluginPath.startsWith('./');
for (i = 0, ii = toAdd.length; i < ii; ++i) {
resource = toAdd[i];
if (typeof resource != 'string') {
throw new Error('Invalid resource path [' + resource + ']. Resources must be specified as relative module IDs.');
}
path = internalPlugin ? _aureliaPath.relativeToFile(resource, pluginPath) : _aureliaPath.join(pluginPath, resource);
this.resourcesToLoad[path] = this.resourcesToLoad[path];
}
return this;
};
Aurelia.prototype.renameGlobalResource = function renameGlobalResource(resourcePath, newName) {
this.resourcesToLoad[resourcePath] = newName;
return this;
};
Aurelia.prototype.start = function start() {
var _this2 = this;
if (this.started) {
return Promise.resolve(this);
}
this.started = true;
logger.info('Aurelia Starting');
preventActionlessFormSubmit();
return this.use._process().then(function () {
if (!_this2.container.hasHandler(_aureliaTemplating.BindingLanguage)) {
var message = 'You must configure Aurelia with a BindingLanguage implementation.';
logger.error(message);
throw new Error(message);
}
if (!_this2.container.hasHandler(_aureliaTemplating.Animator)) {
_aureliaTemplating.Animator.configureDefault(_this2.container);
}
return loadResources(_this2.container, _this2.resourcesToLoad, _this2.resources).then(function () {
logger.info('Aurelia Started');
var evt = new window.CustomEvent('aurelia-started', { bubbles: true, cancelable: true });
document.dispatchEvent(evt);
return _this2;
});
});
};
Aurelia.prototype.setRoot = function setRoot() {
var _this3 = this;
var root = arguments[0] === undefined ? 'app' : arguments[0];
var applicationHost = arguments[1] === undefined ? null : arguments[1];
var compositionEngine,
instruction = {};
applicationHost = applicationHost || this.host;
if (!applicationHost || typeof applicationHost == 'string') {
this.host = document.getElementById(applicationHost || 'applicationHost') || document.body;
} else {
this.host = applicationHost;
}
this.host.aurelia = this;
compositionEngine = this.container.get(_aureliaTemplating.CompositionEngine);
instruction.viewModel = root;
instruction.container = instruction.childContainer = this.container;
instruction.viewSlot = new _aureliaTemplating.ViewSlot(this.host, true);
instruction.viewSlot.transformChildNodesIntoView();
instruction.host = this.host;
return compositionEngine.compose(instruction).then(function (root) {
_this3.root = root;
instruction.viewSlot.attached();
var evt = new window.CustomEvent('aurelia-composed', { bubbles: true, cancelable: true });
setTimeout(function () {
return document.dispatchEvent(evt);
}, 1);
return _this3;
});
};
return Aurelia;
})();
exports.Aurelia = Aurelia;
_defaults(exports, _interopRequireWildcard(_aureliaDependencyInjection));
_defaults(exports, _interopRequireWildcard(_aureliaBinding));
_defaults(exports, _interopRequireWildcard(_aureliaMetadata));
_defaults(exports, _interopRequireWildcard(_aureliaTemplating));
_defaults(exports, _interopRequireWildcard(_aureliaLoader));
_defaults(exports, _interopRequireWildcard(_aureliaTaskQueue));
_defaults(exports, _interopRequireWildcard(_aureliaPath));
var LogManager = _aureliaLogging;
exports.LogManager = LogManager;
});
|
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M13.5 5.5c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zM9.8 8.9L7 23h2.1l1.8-8 2.1 2v6h2v-7.5l-2.1-2 .6-3C14.8 12 16.8 13 19 13v-2c-1.9 0-3.5-1-4.3-2.4l-1-1.6c-.56-.89-1.68-1.25-2.65-.84L6 8.3V13h2V9.6l1.8-.7" />
, 'DirectionsWalkOutlined');
|
module.exports = function() {
return !this.rules.requiredIf || !!this.errors.length;
}
|
'use strict';
var BaseRequest = require('./BaseRequest'),
util = require('util'),
SubscriptionProduct = require('./model/SubscriptionProduct');
function UpdateSubscriptionProductRequest(request) {
BaseRequest.call(this, SubscriptionProduct.body(request));
}
util.inherits(UpdateSubscriptionProductRequest, BaseRequest);
module.exports = UpdateSubscriptionProductRequest;
|
(function () {
'use strict';
angular
.module('porttare.controllers')
.controller('ResetController', ResetController);
function ResetController( $ionicLoading,
$auth,
$ionicPopup,
$state,
$rootScope,
$window,
APP) {
var resetVm = this;
resetVm.updatePassword = updatePassword;
resetVm.resetPassword = resetPassword;
resetVm.updatePasswordForm = {};
resetVm.resetPasswordForm = {};
resetVm.messages = {};
var successState = APP.successState;
var loginState = 'login';
$rootScope.$on('auth:password-change-error', function (event, data) {
resetVm.messages = data.errors;
});
$rootScope.$on('auth:password-change-success', function () {
$window.location.href = '/' + $state.href(successState);
});
function resetPassword() {
$ionicLoading.show({
template: 'enviando...'
});
$auth.requestPasswordReset(resetVm.resetPasswordForm)
.then(function () {
$state.go(loginState).then(function () {
$ionicLoading.show({
template: 'Se enviaron las intrucciones al correo.',
noBackdrop: true,
duration: 2000
});
});
})
.catch(function (err) {
var messsage = err.data ? err.data.errors[0] :
'Hubo un error enviando la información.';
$ionicPopup.alert({
title: 'Error',
template: messsage
});
})
.finally(function () {
$ionicLoading.hide();
});
}
function updatePassword() {
$ionicLoading.show({
template: 'cargando...'
});
$auth.updatePassword(resetVm.updatePasswordForm)
.finally(function () {
$ionicLoading.hide();
});
}
}
})();
|
import {stories, className, func, bool, string} from '../duckyStories';
import PopoverMenuItem3 from './index';
stories(module, PopoverMenuItem3, [
'https://github.com/DuckyTeam/ducky-web/issues/1015'
], {
className: className(),
label: string('Menu Label'),
onClick: func(),
selected: bool()
});
|
'use strict';
/**
* Module dependencies
*/
var mongoose = require('mongoose'),
path = require('path'),
config = require(path.resolve('./config/config')),
Schema = mongoose.Schema,
crypto = require('crypto'),
validator = require('validator'),
generatePassword = require('generate-password'),
owasp = require('owasp-password-strength-test'),
chalk = require('chalk');
owasp.config(config.shared.owasp);
/**
* A Validation function for local strategy properties
*/
var validateLocalStrategyProperty = function (property) {
return ((this.provider !== 'local' && !this.updated) || property.length);
};
/**
* A Validation function for local strategy email
*/
var validateLocalStrategyEmail = function (email) {
return ((this.provider !== 'local' && !this.updated) || validator.isEmail(email, { require_tld: false }));
};
/**
* A Validation function for username
* - at least 3 characters
* - only a-z0-9_-.
* - contain at least one alphanumeric character
* - not in list of illegal usernames
* - no consecutive dots: "." ok, ".." nope
* - not begin or end with "."
*/
var validateUsername = function (username) {
var usernameRegex = /^(?=[\w.-]+$)(?!.*[._-]{2})(?!\.)(?!.*\.$).{3,34}$/;
return (
this.provider !== 'local' ||
(username && usernameRegex.test(username) && config.illegalUsernames.indexOf(username) < 0)
);
};
/**
* User Schema
*/
var UserSchema = new Schema({
firstName: {
type: String,
trim: true,
default: '',
validate: [validateLocalStrategyProperty, 'Please fill in your first name']
},
lastName: {
type: String,
trim: true,
default: '',
validate: [validateLocalStrategyProperty, 'Please fill in your last name']
},
displayName: {
type: String,
trim: true
},
email: {
type: String,
index: {
unique: true,
sparse: true // For this to work on a previously indexed field, the index must be dropped & the application restarted.
},
lowercase: true,
trim: true,
default: '',
validate: [validateLocalStrategyEmail, 'Please fill a valid email address']
},
username: {
type: String,
unique: 'Username already exists',
required: 'Please fill in a username',
validate: [validateUsername, 'Please enter a valid username: 3+ characters long, non restricted word, characters "_-.", no consecutive dots, does not begin or end with dots, letters a-z and numbers 0-9.'],
lowercase: true,
trim: true
},
password: {
type: String,
default: ''
},
salt: {
type: String
},
profileImageURL: {
type: String,
default: '/modules/users/client/img/profile/default.png'
},
provider: {
type: String,
required: 'Provider is required'
},
providerData: {},
additionalProvidersData: {},
roles: {
type: [{
type: String,
enum: ['user', 'instructor', 'student', 'admin']
}],
default: ['user'],
required: 'Please provide at least one role'
},
classroom: {
type: Schema.ObjectId,
ref: 'Classroom'
},
updated: {
type: Date
},
created: {
type: Date,
default: Date.now
},
/* For reset password */
resetPasswordToken: {
type: String
},
resetPasswordExpires: {
type: Date
}
});
/**
* Hook a pre save method to hash the password
*/
UserSchema.pre('save', function (next) {
if (this.password && this.isModified('password')) {
this.salt = crypto.randomBytes(16).toString('base64');
this.password = this.hashPassword(this.password);
}
next();
});
/**
* Hook a pre validate method to test the local password
*/
UserSchema.pre('validate', function (next) {
if (this.provider === 'local' && this.password && this.isModified('password')) {
var result = owasp.test(this.password);
if (result.errors.length) {
var error = result.errors.join(' ');
this.invalidate('password', error);
}
}
next();
});
/**
* Create instance method for hashing a password
*/
UserSchema.methods.hashPassword = function (password) {
if (this.salt && password) {
return crypto.pbkdf2Sync(password, new Buffer(this.salt, 'base64'), 10000, 64, 'SHA1').toString('base64');
} else {
return password;
}
};
/**
* Create instance method for authenticating user
*/
UserSchema.methods.authenticate = function (password) {
return this.password === this.hashPassword(password);
};
/**
* Find possible not used username
*/
UserSchema.statics.findUniqueUsername = function (username, suffix, callback) {
var _this = this;
var possibleUsername = username.toLowerCase() + (suffix || '');
_this.findOne({
username: possibleUsername
}, function (err, user) {
if (!err) {
if (!user) {
callback(possibleUsername);
} else {
return _this.findUniqueUsername(username, (suffix || 0) + 1, callback);
}
} else {
callback(null);
}
});
};
/**
* Generates a random passphrase that passes the owasp test
* Returns a promise that resolves with the generated passphrase, or rejects with an error if something goes wrong.
* NOTE: Passphrases are only tested against the required owasp strength tests, and not the optional tests.
*/
UserSchema.statics.generateRandomPassphrase = function () {
return new Promise(function (resolve, reject) {
var password = '';
var repeatingCharacters = new RegExp('(.)\\1{2,}', 'g');
// iterate until the we have a valid passphrase.
// NOTE: Should rarely iterate more than once, but we need this to ensure no repeating characters are present.
while (password.length < 20 || repeatingCharacters.test(password)) {
// build the random password
password = generatePassword.generate({
length: Math.floor(Math.random() * (20)) + 20, // randomize length between 20 and 40 characters
numbers: true,
symbols: false,
uppercase: true,
excludeSimilarCharacters: true
});
// check if we need to remove any repeating characters
password = password.replace(repeatingCharacters, '');
}
// Send the rejection back if the passphrase fails to pass the strength test
if (owasp.test(password).errors.length) {
reject(new Error('An unexpected problem occured while generating the random passphrase'));
} else {
// resolve with the validated passphrase
resolve(password);
}
});
};
UserSchema.statics.seed = seed;
mongoose.model('User', UserSchema);
/**
* Seeds the User collection with document (User)
* and provided options.
*/
function seed(doc, options) {
var User = mongoose.model('User');
return new Promise(function (resolve, reject) {
skipDocument()
.then(add)
.then(function (response) {
return resolve(response);
})
.catch(function (err) {
return reject(err);
});
function skipDocument() {
return new Promise(function (resolve, reject) {
User
.findOne({
username: doc.username
})
.exec(function (err, existing) {
if (err) {
return reject(err);
}
if (!existing) {
return resolve(false);
}
if (existing && !options.overwrite) {
return resolve(true);
}
// Remove User (overwrite)
existing.remove(function (err) {
if (err) {
return reject(err);
}
return resolve(false);
});
});
});
}
function add(skip) {
return new Promise(function (resolve, reject) {
if (skip) {
return resolve({
message: chalk.yellow('Database Seeding: User\t\t' + doc.username + ' skipped')
});
}
User.generateRandomPassphrase()
.then(function (passphrase) {
var user = new User(doc);
user.provider = 'local';
user.displayName = user.firstName + ' ' + user.lastName;
user.password = passphrase;
user.save(function (err) {
if (err) {
return reject(err);
}
return resolve({
message: 'Database Seeding: User\t\t' + user.username + ' added with password set to ' + passphrase
});
});
})
.catch(function (err) {
return reject(err);
});
});
}
});
}
|
import { computed } from '@ember/object';
import Component from '@ember/component';
export default Component.extend({
tagName: 'tr',
numFiles: computed('gist.files.[]', function() {
return this.get('gist.files.length');
}),
filesTitle: computed('gist.files.@each.filePath', function() {
return this.get('gist.files').toArray().mapBy('filePath').join("\n");
})
});
|
// this should reveal wrong iteration on arrays
Array.prototype.someNewMethod = function() {};
var test = require('unit.js');
describe('winreg', function(){
it('running on Windows', function () {
test.string(process.platform)
. is('win32');
});
// Registry class
var Registry = require(__dirname+'/../../lib/registry.js');
it('Registry is a class', function () {
test.function(Registry)
. hasName('Registry');
});
// create a uniqe registry key in HKCU to test in
var regKey = new Registry({
hive: Registry.HKCU,
key: '\\Software\\AAA_' + new Date().toISOString()
});
it('regKey is instance of Registry', function(){
test.object(regKey)
. isInstanceOf(Registry);
});
// a key that has subkeys in it
var softwareKey = new Registry({
hive: Registry.HKCU,
key: '\\Software'
});
it('softwareKey is instance of Registry', function(){
test.object(softwareKey)
. isInstanceOf(Registry);
});
it('can change the prototype', function (done) {
var magicString = new Date().toISOString();
Registry.prototype.toString = function () {
return magicString;
};
var instance = new Registry({
hive: Registry.HKCU,
key: '\\Software'
});
test.string(instance.toString())
. is(magicString);
done();
});
describe('Registry', function (){
describe('keyExists()', function(){
it('regKey has keyExists method', function () {
test.object(regKey)
. hasProperty('keyExists');
test.function(regKey.keyExists)
. hasName('keyExists');
});
it('regKey does not already exist', function(done) {
regKey.keyExists(function (err, exists) {
if (err) throw err;
test.bool(exists)
. isNotTrue();
done();
});
});
}); // end - describe keyExists()
describe('create()', function(){
it('regKey has create method', function () {
test.object(regKey)
. hasProperty('create');
test.function(regKey.create)
. hasName('create');
});
it('regKey can be created', function(done) {
regKey.create(function (err) {
if (err) throw err;
done();
});
});
it('regKey exists after being created', function(done) {
regKey.keyExists(function (err, exists) {
if (err) throw err;
test.bool(exists)
. isTrue();
done();
});
});
}); // end - describe create()
describe('set()', function (){
it('regKey has set method', function () {
test.object(regKey)
. hasProperty('set');
test.function(regKey.set)
. hasName('set');
});
it('can set a string value', function (done) {
regKey.set('SomeString', Registry.REG_SZ, 'SomeValue', function (err) {
if (err) throw err;
done();
});
});
}); // end - describe set
describe('valueExists()', function (){
it('regKey has valueExists method', function () {
test.object(regKey)
. hasProperty('valueExists');
test.function(regKey.valueExists)
. hasName('valueExists');
});
it('can check for existing string value', function (done) {
regKey.valueExists('SomeString', function (err, exists) {
if (err) throw err;
test.bool(exists)
. isTrue();
done();
});
});
}); // end - describe valueExists
describe('get()', function (){
it('regKey has get method', function () {
test.object(regKey)
. hasProperty('get');
test.function(regKey.get)
. hasName('get');
});
it('can get a string value', function (done) {
regKey.get('SomeString', function (err, item) {
if (err) throw err;
test.object(item)
. hasProperty('value', 'SomeValue');
done();
});
});
}); // end - describe get
describe('values()', function (){
it('regKey has values method', function () {
test.object(regKey)
. hasProperty('values');
test.function(regKey.values)
. hasName('values');
});
it('returns array of RegistryItem objects', function (done) {
regKey.values(function (err, items) {
if (err) throw err;
for (var i=0; i<items.length; i++) {
var item = items[i];
test.object(item)
. hasProperty('value');
}
done();
});
});
}); // end - describe values
describe('remove()', function (){
it('regKey has remove method', function () {
test.object(regKey)
. hasProperty('remove');
test.function(regKey.remove)
. hasName('remove');
});
it('can remove a string value', function (done) {
regKey.remove('SomeString', function (err) {
if (err) throw err;
done();
});
});
}); // end - describe remove
describe('keys()', function (){
it('regKey has keys method', function () {
test.object(regKey)
. hasProperty('keys');
test.function(regKey.keys)
. hasName('keys');
});
it('returns array of Registry objects', function (done) {
softwareKey.keys(function (err, keys) {
if (err) throw err;
test.array(keys);
for (var i=0; i<keys.length; i++) {
var key = keys[i];
test.object(key)
. isInstanceOf(Registry);
}
done();
});
});
}); // end - describe keys()
describe('clear()', function (){
it('regKey has clear method', function () {
test.object(regKey)
. hasProperty('clear');
test.function(regKey.clear)
. hasName('clear');
});
}); // end - describe clear
describe('destroy()', function(){
it('regKey has destroy method', function () {
test.object(regKey)
. hasProperty('destroy');
test.function(regKey.destroy)
. hasName('destroy');
});
it('regKey can be destroyed', function(done) {
regKey.destroy(function (err) {
if (err) throw err;
done();
});
});
it('regKey is missing after being destroyed', function(done) {
regKey.keyExists(function (err, exists) {
if (err) throw err;
test.bool(exists)
. isFalse();
done();
});
});
}); // end - describe destroy()
}); // end - describe Registry
}); // end - describe winreg
|
const {Song} = require('../models')
module.exports = {
async index (req, res) {
try {
let songs = null
const search = req.query.search
if (search) {
songs = await Song.findAll({
where: {
$or: [
'title', 'artist', 'genre', 'album'
].map(key => ({
[key]: {
$like: `%${search}%`
}
}))
}
})
} else {
songs = await Song.findAll({
limit: 10
})
}
res.send(songs)
} catch (err) {
res.status(500).send({
error: 'an error has occured trying to fetch the songs'
})
}
},
async show (req, res) {
try {
const song = await Song.findById(req.params.songId)
res.send(song)
} catch (err) {
res.status(500).send({
error: 'an error has occured trying to show the songs'
})
}
},
async post (req, res) {
try {
const song = await Song.create(req.body)
res.send(song)
} catch (err) {
res.status(500).send({
error: 'an error has occured trying to create the song'
})
}
},
async put (req, res) {
try {
await Song.update(req.body, {
where: {
id: req.params.songId
}
})
res.send(req.body)
} catch (err) {
res.status(500).send({
error: 'an error has occured trying to update the song'
})
}
}
}
|
suite('tick-tests', function() {
setup(function() { webAnimations1.timeline._animations = []; });
test('animations are in effect but ticking stops once forward fill is reached', function() {
tick(90);
var animation = document.body.animate([], {duration: 1000, fill: 'forwards'});
tick(100);
tick(600);
assert.equal(webAnimations1.timeline._animations.length, 1);
assert.equal(isTicking(), true);
tick(1100);
assert.equal(animation.finished, true);
assert.equal(webAnimations1.timeline._animations.length, 1);
assert.equal(isTicking(), false);
});
});
|
import Ember from "ember-metal/core";
import { get } from "ember-metal/property_get";
import { set } from "ember-metal/property_set";
import run from "ember-metal/run_loop";
import EmberObject from "ember-runtime/system/object";
import RSVP from "ember-runtime/ext/rsvp";
import { View as EmberView } from "ember-views/views/view";
import jQuery from "ember-views/system/jquery";
import Test from "ember-testing/test";
import "ember-testing/helpers"; // ensure that the helpers are loaded
import "ember-testing/initializers"; // ensure the initializer is setup
import setupForTesting from "ember-testing/setup_for_testing";
import EmberRouter from "ember-routing/system/router";
import EmberRoute from "ember-routing/system/route";
import EmberApplication from "ember-application/system/application";
var App, originalAdapter = Test.adapter;
function cleanup(){
// Teardown setupForTesting
Test.adapter = originalAdapter;
run(function(){
jQuery(document).off('ajaxSend');
jQuery(document).off('ajaxComplete');
});
Test.pendingAjaxRequests = null;
// Other cleanup
if (App) {
run(App, App.destroy);
App.removeTestHelpers();
App = null;
}
Ember.TEMPLATES = {};
}
function assertHelpers(application, helperContainer, expected){
if (!helperContainer) { helperContainer = window; }
if (expected === undefined) { expected = true; }
function checkHelperPresent(helper, expected){
var presentInHelperContainer = !!helperContainer[helper],
presentInTestHelpers = !!application.testHelpers[helper];
ok(presentInHelperContainer === expected, "Expected '" + helper + "' to be present in the helper container (defaults to window).");
ok(presentInTestHelpers === expected, "Expected '" + helper + "' to be present in App.testHelpers.");
}
checkHelperPresent('visit', expected);
checkHelperPresent('click', expected);
checkHelperPresent('keyEvent', expected);
checkHelperPresent('fillIn', expected);
checkHelperPresent('wait', expected);
checkHelperPresent('triggerEvent', expected);
}
function assertNoHelpers(application, helperContainer) {
assertHelpers(application, helperContainer, false);
}
function currentRouteName(app){
if(Ember.FEATURES.isEnabled('ember-testing-route-helpers')) {
return app.testHelpers.currentRouteName();
} else {
var appController = app.__container__.lookup('controller:application');
return get(appController, 'currentRouteName');
}
}
function currentPath(app){
if(Ember.FEATURES.isEnabled('ember-testing-route-helpers')) {
return app.testHelpers.currentPath();
} else {
var appController = app.__container__.lookup('controller:application');
return get(appController, 'currentPath');
}
}
function currentURL(app){
if(Ember.FEATURES.isEnabled('ember-testing-route-helpers')) {
return app.testHelpers.currentURL();
} else {
var router = app.__container__.lookup('router:main');
return get(router, 'location').getURL();
}
}
QUnit.module("ember-testing Helpers", {
setup: function(){ cleanup(); },
teardown: function() { cleanup(); }
});
test("Ember.Application#injectTestHelpers/#removeTestHelpers", function() {
App = run(EmberApplication, EmberApplication.create);
assertNoHelpers(App);
App.injectTestHelpers();
assertHelpers(App);
App.removeTestHelpers();
assertNoHelpers(App);
});
test("Ember.Application#setupForTesting", function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App.__container__.lookup('router:main').location.implementation, 'none');
});
test("Ember.Application.setupForTesting sets the application to `testing`.", function(){
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App.testing, true, "Application instance is set to testing.");
});
test("Ember.Application.setupForTesting leaves the system in a deferred state.", function(){
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
});
test("App.reset() after Application.setupForTesting leaves the system in a deferred state.", function(){
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
App.reset();
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
});
test("`visit` advances readiness.", function(){
expect(2);
run(function() {
App = EmberApplication.create();
App.setupForTesting();
App.injectTestHelpers();
});
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
App.testHelpers.visit('/').then(function(){
equal(App._readinessDeferrals, 0, "App's readiness was advanced by visit.");
});
});
test("`wait` helper can be passed a resolution value", function() {
expect(4);
var promise, wait;
promise = new RSVP.Promise(function(resolve) {
run(null, resolve, 'promise');
});
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers();
run(App, App.advanceReadiness);
wait = App.testHelpers.wait;
wait('text').then(function(val) {
equal(val, 'text', 'can resolve to a string');
return wait(1);
}).then(function(val) {
equal(val, 1, 'can resolve to an integer');
return wait({ age: 10 });
}).then(function(val) {
deepEqual(val, { age: 10 }, 'can resolve to an object');
return wait(promise);
}).then(function(val) {
equal(val, 'promise', 'can resolve to a promise resolution value');
});
});
test("`click` triggers appropriate events in order", function() {
expect(4);
var click, wait, events;
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.IndexView = EmberView.extend({
classNames: 'index-view',
didInsertElement: function() {
this.$().on('mousedown focusin mouseup click', function(e) {
events.push(e.type);
});
},
Checkbox: Ember.Checkbox.extend({
click: function() {
events.push('click:' + this.get('checked'));
},
change: function() {
events.push('change:' + this.get('checked'));
}
})
});
Ember.TEMPLATES.index = Ember.Handlebars.compile('{{input type="text"}} {{view view.Checkbox}} {{textarea}}');
App.injectTestHelpers();
run(App, App.advanceReadiness);
click = App.testHelpers.click;
wait = App.testHelpers.wait;
wait().then(function() {
events = [];
return click('.index-view');
}).then(function() {
deepEqual(events,
['mousedown', 'mouseup', 'click'],
'fires events in order');
}).then(function() {
events = [];
return click('.index-view input[type=text]');
}).then(function() {
deepEqual(events,
['mousedown', 'focusin', 'mouseup', 'click'],
'fires focus events on inputs');
}).then(function() {
events = [];
return click('.index-view textarea');
}).then(function() {
deepEqual(events,
['mousedown', 'focusin', 'mouseup', 'click'],
'fires focus events on textareas');
}).then(function() {
// In IE (< 8), the change event only fires when the value changes before element focused.
jQuery('.index-view input[type=checkbox]').focus();
events = [];
return click('.index-view input[type=checkbox]');
}).then(function() {
// i.e. mousedown, mouseup, change:true, click, click:true
// Firefox differs so we can't assert the exact ordering here.
// See https://bugzilla.mozilla.org/show_bug.cgi?id=843554.
equal(events.length, 5, 'fires click and change on checkboxes');
});
});
test("Ember.Application#setupForTesting attaches ajax listeners", function() {
var documentEvents;
documentEvents = jQuery._data(document, 'events');
if (!documentEvents) {
documentEvents = {};
}
ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listers setup prior to calling injectTestHelpers');
ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listers setup prior to calling injectTestHelpers');
run(function() {
setupForTesting();
});
documentEvents = jQuery._data(document, 'events');
equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
});
test("Ember.Application#setupForTesting attaches ajax listeners only once", function() {
var documentEvents;
documentEvents = jQuery._data(document, 'events');
if (!documentEvents) {
documentEvents = {};
}
ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listers setup prior to calling injectTestHelpers');
ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listers setup prior to calling injectTestHelpers');
run(function() {
setupForTesting();
});
run(function() {
setupForTesting();
});
documentEvents = jQuery._data(document, 'events');
equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
});
test("Ember.Application#injectTestHelpers calls callbacks registered with onInjectHelpers", function(){
var injected = 0;
Test.onInjectHelpers(function(){
injected++;
});
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(injected, 0, 'onInjectHelpers are not called before injectTestHelpers');
App.injectTestHelpers();
equal(injected, 1, 'onInjectHelpers are called after injectTestHelpers');
});
test("Ember.Application#injectTestHelpers adds helpers to provided object.", function(){
var helpers = {};
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers(helpers);
assertHelpers(App, helpers);
App.removeTestHelpers();
assertNoHelpers(App, helpers);
});
test("Ember.Application#removeTestHelpers resets the helperContainer's original values", function(){
var helpers = {visit: 'snazzleflabber'};
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers(helpers);
ok(helpers['visit'] !== 'snazzleflabber', "helper added to container");
App.removeTestHelpers();
ok(helpers['visit'] === 'snazzleflabber', "original value added back to container");
});
test("`wait` respects registerWaiters", function() {
expect(2);
var counter=0;
function waiter() {
return ++counter > 2;
}
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers();
run(App, App.advanceReadiness);
Test.registerWaiter(waiter);
App.testHelpers.wait().then(function() {
equal(waiter(), true, 'should not resolve until our waiter is ready');
Test.unregisterWaiter(waiter);
equal(Test.waiters.length, 0, 'should not leave a waiter registered');
});
});
test("`wait` waits for outstanding timers", function() {
expect(1);
var wait_done = false;
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers();
run(App, App.advanceReadiness);
run.later(this, function() {
wait_done = true;
}, 500);
App.testHelpers.wait().then(function() {
equal(wait_done, true, 'should wait for the timer to be fired.');
});
});
test("`wait` respects registerWaiters with optional context", function() {
expect(2);
var obj = {
counter: 0,
ready: function() {
return ++this.counter > 2;
}
};
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers();
run(App, App.advanceReadiness);
Test.registerWaiter(obj, obj.ready);
App.testHelpers.wait().then(function() {
equal(obj.ready(), true, 'should not resolve until our waiter is ready');
Test.unregisterWaiter(obj, obj.ready);
equal(Test.waiters.length, 0, 'should not leave a waiter registered');
});
});
QUnit.module("ember-testing routing helpers", {
setup: function(){
cleanup();
run(function() {
App = EmberApplication.create();
App.Router = EmberRouter.extend({
location: 'none'
});
App.Router.map(function() {
this.resource("posts", function() {
this.route("new");
});
});
App.setupForTesting();
});
App.injectTestHelpers();
run(App, 'advanceReadiness');
},
teardown: function(){
cleanup();
}
});
test("currentRouteName for '/'", function(){
expect(3);
App.testHelpers.visit('/').then(function(){
equal(App.testHelpers.currentRouteName(), 'index', "should equal 'index'.");
equal(App.testHelpers.currentPath(), 'index', "should equal 'index'.");
equal(App.testHelpers.currentURL(), '/', "should equal '/'.");
});
});
test("currentRouteName for '/posts'", function(){
expect(3);
App.testHelpers.visit('/posts').then(function(){
equal(App.testHelpers.currentRouteName(), 'posts.index', "should equal 'posts.index'.");
equal(App.testHelpers.currentPath(), 'posts.index', "should equal 'posts.index'.");
equal(App.testHelpers.currentURL(), '/posts', "should equal '/posts'.");
});
});
test("currentRouteName for '/posts/new'", function(){
expect(3);
App.testHelpers.visit('/posts/new').then(function(){
equal(App.testHelpers.currentRouteName(), 'posts.new', "should equal 'posts.new'.");
equal(App.testHelpers.currentPath(), 'posts.new', "should equal 'posts.new'.");
equal(App.testHelpers.currentURL(), '/posts/new', "should equal '/posts/new'.");
});
});
QUnit.module("ember-testing pendingAjaxRequests", {
setup: function(){
cleanup();
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers();
},
teardown: function() { cleanup(); }
});
test("pendingAjaxRequests is maintained for ajaxSend and ajaxComplete events", function() {
equal(Test.pendingAjaxRequests, 0);
var xhr = {some: 'xhr'};
jQuery(document).trigger('ajaxSend', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
jQuery(document).trigger('ajaxComplete', xhr);
equal(Test.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was decremented');
});
test("pendingAjaxRequests is ignores ajaxComplete events from past setupForTesting calls", function() {
equal(Test.pendingAjaxRequests, 0);
var xhr = {some: 'xhr'};
jQuery(document).trigger('ajaxSend', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
Ember.run(function(){
setupForTesting();
});
equal(Test.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was reset');
var altXhr = {some: 'more xhr'};
jQuery(document).trigger('ajaxSend', altXhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
jQuery(document).trigger('ajaxComplete', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests is not impressed with your unexpected complete');
});
test("pendingAjaxRequests is reset by setupForTesting", function() {
Test.pendingAjaxRequests = 1;
Ember.run(function(){
setupForTesting();
});
equal(Test.pendingAjaxRequests, 0, 'pendingAjaxRequests is reset');
});
test("`trigger` can be used to trigger arbitrary events", function() {
expect(2);
var triggerEvent, wait, event;
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.IndexView = EmberView.extend({
template: Ember.Handlebars.compile('{{input type="text" id="foo"}}'),
didInsertElement: function() {
this.$('#foo').on('blur change', function(e) {
event = e;
});
}
});
App.injectTestHelpers();
run(App, App.advanceReadiness);
triggerEvent = App.testHelpers.triggerEvent;
wait = App.testHelpers.wait;
wait().then(function() {
return triggerEvent('#foo', 'blur');
}).then(function() {
equal(event.type, 'blur', 'correct event was triggered');
equal(event.target.getAttribute('id'), 'foo', 'triggered on the correct element');
});
});
QUnit.module("ember-testing async router", {
setup: function(){
cleanup();
run(function() {
App = EmberApplication.create();
App.Router = EmberRouter.extend({
location: 'none'
});
App.Router.map(function() {
this.resource("user", function() {
this.route("profile");
this.route("edit");
});
});
App.UserRoute = EmberRoute.extend({
model: function() {
return resolveLater();
}
});
App.UserProfileRoute = EmberRoute.extend({
beforeModel: function() {
var self = this;
return resolveLater().then(function() {
self.transitionTo('user.edit');
});
}
});
// Emulates a long-running unscheduled async operation.
function resolveLater() {
var promise;
run(function() {
promise = new RSVP.Promise(function(resolve) {
// The wait() helper has a 10ms tick. We should resolve() after at least one tick
// to test whether wait() held off while the async router was still loading. 20ms
// should be enough.
setTimeout(function() {
run(function() {
resolve(EmberObject.create({firstName: 'Tom'}));
});
}, 20);
});
});
return promise;
}
App.setupForTesting();
});
App.injectTestHelpers();
run(App, 'advanceReadiness');
},
teardown: function(){
cleanup();
}
});
test("currentRouteName for '/user'", function(){
expect(4);
App.testHelpers.visit('/user').then(function(){
equal(currentRouteName(App), 'user.index', "should equal 'user.index'.");
equal(currentPath(App), 'user.index', "should equal 'user.index'.");
equal(currentURL(App), '/user', "should equal '/user'.");
equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', "should equal 'Tom'.");
});
});
test("currentRouteName for '/user/profile'", function(){
expect(4);
App.testHelpers.visit('/user/profile').then(function(){
equal(currentRouteName(App), 'user.edit', "should equal 'user.edit'.");
equal(currentPath(App), 'user.edit', "should equal 'user.edit'.");
equal(currentURL(App), '/user/edit', "should equal '/user/edit'.");
equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', "should equal 'Tom'.");
});
});
|
const validate = values => {
const keys = Object.keys(values);
return keys.reduce(
(errors, valueKey) => {
if (values[valueKey]) return errors;
errors[valueKey] = 'Required';
return errors;
},
{}
);
};
export default validate;
|
/* global fullpage */
"use strict";
window.onload = function() {
function fire() {
fullpage.init("#sectionContent", {
pageSpeed: 500,
beforeLeave: function(leaveIndex, nowIndex) {
if (nowIndex === 2) {
//console.log('You will leave page 2');
}
//console.log(this, leaveIndex, nowIndex);
},
afterLoad: function(afterIndex) {
if (afterIndex === 2) {
//console.log('You will go to page 2');
}
//console.log(this, afterIndex);
},
beforeSlideLeave: function(pageIndex, slideNow, slideAfter) {
var _this = this;
var SlideNow = document.querySelector("#nowSlide");
SlideNow.innerHTML = "Slide" + slideAfter;
},
afterSlideLoad: function(pageIndex, slideIndex) {
var _this = this;
}
});
}
fire();
window.addEventListener("resize", () => {
fire();
});
};
|
this.primereact = this.primereact || {};
this.primereact.overlaypanel = (function (exports, React, core) {
'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof(obj) {
return typeof obj;
};
} else {
_typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _possibleConstructorReturn(self, call) {
if (call && (_typeof(call) === "object" || typeof call === "function")) {
return call;
}
return _assertThisInitialized(self);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
var OverlayPanel = /*#__PURE__*/function (_Component) {
_inherits(OverlayPanel, _Component);
var _super = _createSuper(OverlayPanel);
function OverlayPanel(props) {
var _this;
_classCallCheck(this, OverlayPanel);
_this = _super.call(this, props);
_this.state = {
visible: false
};
_this.onCloseClick = _this.onCloseClick.bind(_assertThisInitialized(_this));
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
_this.attributeSelector = core.UniqueComponentId();
_this.overlayRef = /*#__PURE__*/React__default['default'].createRef();
return _this;
}
_createClass(OverlayPanel, [{
key: "bindDocumentClickListener",
value: function bindDocumentClickListener() {
var _this2 = this;
if (!this.documentClickListener && this.props.dismissable) {
this.documentClickListener = function (event) {
if (!_this2.isPanelClicked && _this2.isOutsideClicked(event.target)) {
_this2.hide();
}
_this2.isPanelClicked = false;
};
document.addEventListener('click', this.documentClickListener);
}
}
}, {
key: "unbindDocumentClickListener",
value: function unbindDocumentClickListener() {
if (this.documentClickListener) {
document.removeEventListener('click', this.documentClickListener);
this.documentClickListener = null;
}
}
}, {
key: "bindScrollListener",
value: function bindScrollListener() {
var _this3 = this;
if (!this.scrollHandler) {
this.scrollHandler = new core.ConnectedOverlayScrollHandler(this.target, function () {
if (_this3.state.visible) {
_this3.hide();
}
});
}
this.scrollHandler.bindScrollListener();
}
}, {
key: "unbindScrollListener",
value: function unbindScrollListener() {
if (this.scrollHandler) {
this.scrollHandler.unbindScrollListener();
}
}
}, {
key: "bindResizeListener",
value: function bindResizeListener() {
var _this4 = this;
if (!this.resizeListener) {
this.resizeListener = function () {
if (_this4.state.visible && !core.DomHandler.isAndroid()) {
_this4.hide();
}
};
window.addEventListener('resize', this.resizeListener);
}
}
}, {
key: "unbindResizeListener",
value: function unbindResizeListener() {
if (this.resizeListener) {
window.removeEventListener('resize', this.resizeListener);
this.resizeListener = null;
}
}
}, {
key: "isOutsideClicked",
value: function isOutsideClicked(target) {
return this.overlayRef && this.overlayRef.current && !(this.overlayRef.current.isSameNode(target) || this.overlayRef.current.contains(target));
}
}, {
key: "hasTargetChanged",
value: function hasTargetChanged(event, target) {
return this.target != null && this.target !== (target || event.currentTarget || event.target);
}
}, {
key: "onCloseClick",
value: function onCloseClick(event) {
this.hide();
event.preventDefault();
}
}, {
key: "onPanelClick",
value: function onPanelClick(event) {
this.isPanelClicked = true;
core.OverlayService.emit('overlay-click', {
originalEvent: event,
target: this.target
});
}
}, {
key: "toggle",
value: function toggle(event, target) {
var _this5 = this;
if (this.state.visible) {
this.hide();
if (this.hasTargetChanged(event, target)) {
this.target = target || event.currentTarget || event.target;
setTimeout(function () {
_this5.show(event, _this5.target);
}, 200);
}
} else {
this.show(event, target);
}
}
}, {
key: "show",
value: function show(event, target) {
var _this6 = this;
this.target = target || event.currentTarget || event.target;
if (this.state.visible) {
this.align();
} else {
this.setState({
visible: true
}, function () {
_this6.overlayEventListener = function (e) {
if (!_this6.isOutsideClicked(e.target)) {
_this6.isPanelClicked = true;
}
};
core.OverlayService.on('overlay-click', _this6.overlayEventListener);
});
}
}
}, {
key: "hide",
value: function hide() {
var _this7 = this;
this.setState({
visible: false
}, function () {
core.OverlayService.off('overlay-click', _this7.overlayEventListener);
_this7.overlayEventListener = null;
});
}
}, {
key: "onEnter",
value: function onEnter() {
core.ZIndexUtils.set('overlay', this.overlayRef.current);
this.overlayRef.current.setAttribute(this.attributeSelector, '');
this.align();
}
}, {
key: "onEntered",
value: function onEntered() {
this.bindDocumentClickListener();
this.bindScrollListener();
this.bindResizeListener();
this.props.onShow && this.props.onShow();
}
}, {
key: "onExit",
value: function onExit() {
this.unbindDocumentClickListener();
this.unbindScrollListener();
this.unbindResizeListener();
}
}, {
key: "onExited",
value: function onExited() {
core.ZIndexUtils.clear(this.overlayRef.current);
this.props.onHide && this.props.onHide();
}
}, {
key: "align",
value: function align() {
if (this.target) {
core.DomHandler.absolutePosition(this.overlayRef.current, this.target);
var containerOffset = core.DomHandler.getOffset(this.overlayRef.current);
var targetOffset = core.DomHandler.getOffset(this.target);
var arrowLeft = 0;
if (containerOffset.left < targetOffset.left) {
arrowLeft = targetOffset.left - containerOffset.left;
}
this.overlayRef.current.style.setProperty('--overlayArrowLeft', "".concat(arrowLeft, "px"));
if (containerOffset.top < targetOffset.top) {
core.DomHandler.addClass(this.overlayRef.current, 'p-overlaypanel-flipped');
}
}
}
}, {
key: "createStyle",
value: function createStyle() {
if (!this.styleElement) {
this.styleElement = document.createElement('style');
document.head.appendChild(this.styleElement);
var innerHTML = '';
for (var breakpoint in this.props.breakpoints) {
innerHTML += "\n @media screen and (max-width: ".concat(breakpoint, ") {\n .p-overlaypanel[").concat(this.attributeSelector, "] {\n width: ").concat(this.props.breakpoints[breakpoint], " !important;\n }\n }\n ");
}
this.styleElement.innerHTML = innerHTML;
}
}
}, {
key: "componentDidMount",
value: function componentDidMount() {
if (this.props.breakpoints) {
this.createStyle();
}
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
this.unbindDocumentClickListener();
this.unbindResizeListener();
if (this.scrollHandler) {
this.scrollHandler.destroy();
this.scrollHandler = null;
}
if (this.styleElement) {
document.head.removeChild(this.styleElement);
this.styleElement = null;
}
if (this.overlayEventListener) {
core.OverlayService.off('overlay-click', this.overlayEventListener);
this.overlayEventListener = null;
}
core.ZIndexUtils.clear(this.overlayRef.current);
}
}, {
key: "renderCloseIcon",
value: function renderCloseIcon() {
if (this.props.showCloseIcon) {
return /*#__PURE__*/React__default['default'].createElement("button", {
type: "button",
className: "p-overlaypanel-close p-link",
onClick: this.onCloseClick,
"aria-label": this.props.ariaCloseLabel
}, /*#__PURE__*/React__default['default'].createElement("span", {
className: "p-overlaypanel-close-icon pi pi-times"
}), /*#__PURE__*/React__default['default'].createElement(core.Ripple, null));
}
return null;
}
}, {
key: "renderElement",
value: function renderElement() {
var className = core.classNames('p-overlaypanel p-component', this.props.className);
var closeIcon = this.renderCloseIcon();
return /*#__PURE__*/React__default['default'].createElement(core.CSSTransition, {
nodeRef: this.overlayRef,
classNames: "p-overlaypanel",
in: this.state.visible,
timeout: {
enter: 120,
exit: 100
},
options: this.props.transitionOptions,
unmountOnExit: true,
onEnter: this.onEnter,
onEntered: this.onEntered,
onExit: this.onExit,
onExited: this.onExited
}, /*#__PURE__*/React__default['default'].createElement("div", {
ref: this.overlayRef,
id: this.props.id,
className: className,
style: this.props.style,
onClick: this.onPanelClick
}, /*#__PURE__*/React__default['default'].createElement("div", {
className: "p-overlaypanel-content"
}, this.props.children), closeIcon));
}
}, {
key: "render",
value: function render() {
var element = this.renderElement();
return /*#__PURE__*/React__default['default'].createElement(core.Portal, {
element: element,
appendTo: this.props.appendTo
});
}
}]);
return OverlayPanel;
}(React.Component);
_defineProperty(OverlayPanel, "defaultProps", {
id: null,
dismissable: true,
showCloseIcon: false,
style: null,
className: null,
appendTo: null,
breakpoints: null,
ariaCloseLabel: 'close',
transitionOptions: null,
onShow: null,
onHide: null
});
exports.OverlayPanel = OverlayPanel;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
}({}, React, primereact.core));
|
define(
//begin v1.x content
{
"days-standAlone-short": [
"Κυ",
"Δε",
"Τρ",
"Τε",
"Πέ",
"Πα",
"Σά"
],
"months-format-narrow": [
"Ι",
"Φ",
"Μ",
"Α",
"Μ",
"Ι",
"Ι",
"Α",
"Σ",
"Ο",
"Ν",
"Δ"
],
"field-second-relative+0": "τώρα",
"field-weekday": "Ημέρα εβδομάδας",
"field-wed-relative+0": "αυτήν την Τετάρτη",
"field-wed-relative+1": "επόμενη Τετάρτη",
"dateFormatItem-GyMMMEd": "E, d MMM y G",
"dateFormatItem-MMMEd": "E, d MMM",
"field-tue-relative+-1": "προηγούμενη Τρίτη",
"days-format-short": [
"Κυ",
"Δε",
"Τρ",
"Τε",
"Πέ",
"Πα",
"Σά"
],
"dateFormat-long": "d MMMM y G",
"field-fri-relative+-1": "προηγούμενη Παρασκευή",
"field-wed-relative+-1": "προηγούμενη Τετάρτη",
"months-format-wide": [
"Ιανουαρίου",
"Φεβρουαρίου",
"Μαρτίου",
"Απριλίου",
"Μαΐου",
"Ιουνίου",
"Ιουλίου",
"Αυγούστου",
"Σεπτεμβρίου",
"Οκτωβρίου",
"Νοεμβρίου",
"Δεκεμβρίου"
],
"dateTimeFormat-medium": "{1} - {0}",
"dayPeriods-format-wide-pm": "μ.μ.",
"dateFormat-full": "EEEE, d MMMM y G",
"dateFormatItem-yyyyMEd": "E, d/M/y GGGGG",
"field-thu-relative+-1": "επόμενη Πέμπτη",
"dateFormatItem-Md": "d/M",
"field-era": "Περίοδος",
"months-standAlone-wide": [
"Ιανουάριος",
"Φεβρουάριος",
"Μάρτιος",
"Απρίλιος",
"Μάιος",
"Ιούνιος",
"Ιούλιος",
"Αύγουστος",
"Σεπτέμβριος",
"Οκτώβριος",
"Νοέμβριος",
"Δεκέμβριος"
],
"timeFormat-short": "h:mm a",
"quarters-format-wide": [
"1ο τρίμηνο",
"2ο τρίμηνο",
"3ο τρίμηνο",
"4ο τρίμηνο"
],
"timeFormat-long": "h:mm:ss a z",
"field-year": "Έτος",
"field-hour": "Ώρα",
"months-format-abbr": [
"Ιαν",
"Φεβ",
"Μαρ",
"Απρ",
"Μαΐ",
"Ιουν",
"Ιουλ",
"Αυγ",
"Σεπ",
"Οκτ",
"Νοε",
"Δεκ"
],
"field-sat-relative+0": "αυτό το Σάββατο",
"field-sat-relative+1": "επόμενο Σάββατο",
"timeFormat-full": "h:mm:ss a zzzz",
"field-day-relative+0": "σήμερα",
"field-thu-relative+0": "αυτήν την Πέμπτη",
"field-day-relative+1": "αύριο",
"field-thu-relative+1": "επόμενη Πέμπτη",
"dateFormatItem-GyMMMd": "d MMM y G",
"field-day-relative+2": "μεθαύριο",
"months-standAlone-abbr": [
"Ιαν",
"Φεβ",
"Μάρ",
"Απρ",
"Μάι",
"Ιούν",
"Ιούλ",
"Αύγ",
"Σεπ",
"Οκτ",
"Νοέ",
"Δεκ"
],
"quarters-format-abbr": [
"Τ1",
"Τ2",
"Τ3",
"Τ4"
],
"quarters-standAlone-wide": [
"1ο τρίμηνο",
"2ο τρίμηνο",
"3ο τρίμηνο",
"4ο τρίμηνο"
],
"dateFormatItem-Gy": "y G",
"dateFormatItem-yyyyMMMEd": "E, d MMM y G",
"days-standAlone-wide": [
"Κυριακή",
"Δευτέρα",
"Τρίτη",
"Τετάρτη",
"Πέμπτη",
"Παρασκευή",
"Σάββατο"
],
"dateFormatItem-yyyyMMM": "MMM y G",
"dateFormatItem-yyyyMMMd": "d MMM y G",
"timeFormat-medium": "h:mm:ss a",
"field-sun-relative+0": "αυτήν την Κυριακή",
"field-sun-relative+1": "επόμενη Κυριακή",
"quarters-standAlone-abbr": [
"Τ1",
"Τ2",
"Τ3",
"Τ4"
],
"eraAbbr": [
"BE"
],
"field-minute": "Λεπτό",
"field-dayperiod": "π.μ./μ.μ.",
"days-standAlone-abbr": [
"Κυρ",
"Δευ",
"Τρί",
"Τετ",
"Πέμ",
"Παρ",
"Σάβ"
],
"field-day-relative+-1": "χθες",
"dateTimeFormat-long": "{1} - {0}",
"field-day-relative+-2": "προχθές",
"dateFormatItem-MMMd": "d MMM",
"dateFormatItem-MEd": "E, d/M",
"dateTimeFormat-full": "{1} - {0}",
"field-fri-relative+0": "αυτήν την Παρασκευή",
"field-fri-relative+1": "επόμενη Παρασκευή",
"field-day": "Ημέρα",
"days-format-wide": [
"Κυριακή",
"Δευτέρα",
"Τρίτη",
"Τετάρτη",
"Πέμπτη",
"Παρασκευή",
"Σάββατο"
],
"field-zone": "Ζώνη ώρας",
"dateFormatItem-y": "y G",
"months-standAlone-narrow": [
"Ι",
"Φ",
"Μ",
"Α",
"Μ",
"Ι",
"Ι",
"Α",
"Σ",
"Ο",
"Ν",
"Δ"
],
"field-year-relative+-1": "προηγούμενο έτος",
"field-month-relative+-1": "προηγούμενος μήνας",
"days-format-abbr": [
"Κυρ",
"Δευ",
"Τρί",
"Τετ",
"Πέμ",
"Παρ",
"Σάβ"
],
"days-format-narrow": [
"Κ",
"Δ",
"Τ",
"Τ",
"Π",
"Π",
"Σ"
],
"dateFormatItem-yyyyMd": "d/M/y GGGGG",
"field-month": "Μήνας",
"days-standAlone-narrow": [
"Κ",
"Δ",
"Τ",
"Τ",
"Π",
"Π",
"Σ"
],
"field-tue-relative+0": "αυτήν την Τρίτη",
"field-tue-relative+1": "επόμενη Τρίτη",
"dayPeriods-format-wide-am": "π.μ.",
"field-mon-relative+0": "αυτήν τη Δευτέρα",
"field-mon-relative+1": "επόμενη Δευτέρα",
"dateFormat-short": "d/M/y GGGGG",
"field-second": "Δευτερόλεπτο",
"field-sat-relative+-1": "προηγούμενο Σάββατο",
"field-sun-relative+-1": "προηγούμενη Κυριακή",
"field-month-relative+0": "τρέχων μήνας",
"field-month-relative+1": "επόμενος μήνας",
"dateFormatItem-Ed": "E d",
"field-week": "Εβδομάδα",
"dateFormat-medium": "d MMM y G",
"field-year-relative+0": "φέτος",
"field-week-relative+-1": "προηγούμενη εβδομάδα",
"dateFormatItem-yyyyM": "M/y GGGGG",
"field-year-relative+1": "επόμενο έτος",
"dateTimeFormat-short": "{1} - {0}",
"dateFormatItem-GyMMM": "MMM y G",
"field-mon-relative+-1": "προηγούμενη Δευτέρα",
"dateFormatItem-yyyy": "y G",
"field-week-relative+0": "αυτήν την εβδομάδα",
"field-week-relative+1": "επόμενη εβδομάδα"
}
//end v1.x content
);
|
exports.notPlugin = true;
var NO_INDEX_TAGS = ['noindex'];
exports.checkRobots = function(noindexHeader, cb) {
if (noindexHeader) {
var i;
for(i = 0; i < NO_INDEX_TAGS.length; i++) {
if (noindexHeader.indexOf(NO_INDEX_TAGS[i]) > -1) {
cb({
responseStatusCode: 403
});
return true;
}
}
}
};
|
pageflow.HighlightedPage = pageflow.Object.extend({
initialize: function(entryData, options) {
this.customNavigationBarMode = options && options.customNavigationBarMode;
this.entry = entryData;
},
getPagePermaId: function(currentPagePermaId) {
var storylineId = this.entry.getStorylineIdByPagePermaId(currentPagePermaId);
if (this.getNavigationBarMode(storylineId) === 'inherit_from_parent') {
var parentPagePermaId = this.entry.getParentPagePermaId(storylineId);
return parentPagePermaId &&
this.getPagePermaId(parentPagePermaId);
}
else {
return this.getDisplayedPageInChapter(currentPagePermaId);
}
},
getDisplayedPageInChapter: function(pagePermaId) {
return _(this.getChapterPagesUntil(pagePermaId).reverse()).find(function(permaId) {
return this.pageIsDisplayedInNavigation(permaId);
}, this);
},
pageIsDisplayedInNavigation: function(permaId) {
return this.entry.getPageConfiguration(permaId).display_in_navigation !== false;
},
getNavigationBarMode: function(storylineId) {
if (this.customNavigationBarMode) {
return this.customNavigationBarMode(storylineId, this.entry);
}
else {
return this.entry.getStorylineConfiguration(storylineId).navigation_bar_mode;
}
},
getChapterPagesUntil: function(pagePermaId) {
var found = false;
var chapterId = this.entry.getChapterIdByPagePermaId(pagePermaId);
return _.filter(this.entry.getChapterPagePermaIds(chapterId), function(other) {
var result = !found;
found = found || (pagePermaId === other);
return result;
});
}
});
pageflow.HighlightedPage.create = function(options) {
return new pageflow.HighlightedPage(pageflow.entryData, options);
};
|
(function() {
angular.module('wikitree.search').
controller('searchController', ['$scope', '$location', 'Search',
function($scope, $location, Search) {
$scope.inputText = '';
$scope.get_suggestions = function (term) {
return Search.get_suggestions(term);
};
$scope.tryEnter = function ($event) {
if ($event.keyCode === 13) {
$event.preventDefault();
$scope.start_search(true);
}
};
$scope.start_search = function (isButton) {
var term = $scope.inputText;
//if (term) {
// if ($scope.new_session) {
// $location.path('/new/' + term);
// } else {
// $scope.session.do_search(term)
// }
//}
console.log('is_button', isButton);
if (term) {
if ($scope.new_session) {
if (isButton) {
$location.path('/new/' + term + '/true');
} else {
$location.path('/new/' + term);
}
} else {
if (isButton) {
$scope.session.do_search(term, null, null, true);
} else {
$scope.session.do_search(term);
}
}
}
$scope.inputText = '';
};
}]);
})();
|
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @emails react-core
*/
'use strict';
var React;
var ReactDOM;
var TestComponent;
describe('ReactCompositeComponent-state', () => {
beforeEach(() => {
React = require('react');
ReactDOM = require('react-dom');
TestComponent = class extends React.Component {
constructor(props) {
super(props);
this.peekAtState('getInitialState', undefined, props);
this.state = {color: 'red'};
}
peekAtState = (from, state = this.state, props = this.props) => {
props.stateListener(from, state && state.color);
};
peekAtCallback = from => {
return () => this.peekAtState(from);
};
setFavoriteColor(nextColor) {
this.setState(
{color: nextColor},
this.peekAtCallback('setFavoriteColor'),
);
}
render() {
this.peekAtState('render');
return <div>{this.state.color}</div>;
}
componentWillMount() {
this.peekAtState('componentWillMount-start');
this.setState(function(state) {
this.peekAtState('before-setState-sunrise', state);
});
this.setState(
{color: 'sunrise'},
this.peekAtCallback('setState-sunrise'),
);
this.setState(function(state) {
this.peekAtState('after-setState-sunrise', state);
});
this.peekAtState('componentWillMount-after-sunrise');
this.setState(
{color: 'orange'},
this.peekAtCallback('setState-orange'),
);
this.setState(function(state) {
this.peekAtState('after-setState-orange', state);
});
this.peekAtState('componentWillMount-end');
}
componentDidMount() {
this.peekAtState('componentDidMount-start');
this.setState(
{color: 'yellow'},
this.peekAtCallback('setState-yellow'),
);
this.peekAtState('componentDidMount-end');
}
componentWillReceiveProps(newProps) {
this.peekAtState('componentWillReceiveProps-start');
if (newProps.nextColor) {
this.setState(function(state) {
this.peekAtState('before-setState-receiveProps', state);
return {color: newProps.nextColor};
});
// No longer a public API, but we can test that it works internally by
// reaching into the updater.
this.updater.enqueueReplaceState(this, {color: undefined});
this.setState(function(state) {
this.peekAtState('before-setState-again-receiveProps', state);
return {color: newProps.nextColor};
}, this.peekAtCallback('setState-receiveProps'));
this.setState(function(state) {
this.peekAtState('after-setState-receiveProps', state);
});
}
this.peekAtState('componentWillReceiveProps-end');
}
shouldComponentUpdate(nextProps, nextState) {
this.peekAtState('shouldComponentUpdate-currentState');
this.peekAtState('shouldComponentUpdate-nextState', nextState);
return true;
}
componentWillUpdate(nextProps, nextState) {
this.peekAtState('componentWillUpdate-currentState');
this.peekAtState('componentWillUpdate-nextState', nextState);
}
componentDidUpdate(prevProps, prevState) {
this.peekAtState('componentDidUpdate-currentState');
this.peekAtState('componentDidUpdate-prevState', prevState);
}
componentWillUnmount() {
this.peekAtState('componentWillUnmount');
}
};
});
it('should support setting state', () => {
var container = document.createElement('div');
document.body.appendChild(container);
var stateListener = jest.fn();
var instance = ReactDOM.render(
<TestComponent stateListener={stateListener} />,
container,
function peekAtInitialCallback() {
this.peekAtState('initial-callback');
},
);
ReactDOM.render(
<TestComponent stateListener={stateListener} nextColor="green" />,
container,
instance.peekAtCallback('setProps'),
);
instance.setFavoriteColor('blue');
instance.forceUpdate(instance.peekAtCallback('forceUpdate'));
ReactDOM.unmountComponentAtNode(container);
let expected = [
// there is no state when getInitialState() is called
['getInitialState', null],
['componentWillMount-start', 'red'],
// setState()'s only enqueue pending states.
['componentWillMount-after-sunrise', 'red'],
['componentWillMount-end', 'red'],
// pending state queue is processed
['before-setState-sunrise', 'red'],
['after-setState-sunrise', 'sunrise'],
['after-setState-orange', 'orange'],
// pending state has been applied
['render', 'orange'],
['componentDidMount-start', 'orange'],
// setState-sunrise and setState-orange should be called here,
// after the bug in #1740
// componentDidMount() called setState({color:'yellow'}), which is async.
// The update doesn't happen until the next flush.
['componentDidMount-end', 'orange'],
['setState-sunrise', 'orange'],
['setState-orange', 'orange'],
['initial-callback', 'orange'],
['shouldComponentUpdate-currentState', 'orange'],
['shouldComponentUpdate-nextState', 'yellow'],
['componentWillUpdate-currentState', 'orange'],
['componentWillUpdate-nextState', 'yellow'],
['render', 'yellow'],
['componentDidUpdate-currentState', 'yellow'],
['componentDidUpdate-prevState', 'orange'],
['setState-yellow', 'yellow'],
['componentWillReceiveProps-start', 'yellow'],
// setState({color:'green'}) only enqueues a pending state.
['componentWillReceiveProps-end', 'yellow'],
// pending state queue is processed
// We keep updates in the queue to support
// replaceState(prevState => newState).
['before-setState-receiveProps', 'yellow'],
['before-setState-again-receiveProps', undefined],
['after-setState-receiveProps', 'green'],
['shouldComponentUpdate-currentState', 'yellow'],
['shouldComponentUpdate-nextState', 'green'],
['componentWillUpdate-currentState', 'yellow'],
['componentWillUpdate-nextState', 'green'],
['render', 'green'],
['componentDidUpdate-currentState', 'green'],
['componentDidUpdate-prevState', 'yellow'],
['setState-receiveProps', 'green'],
['setProps', 'green'],
// setFavoriteColor('blue')
['shouldComponentUpdate-currentState', 'green'],
['shouldComponentUpdate-nextState', 'blue'],
['componentWillUpdate-currentState', 'green'],
['componentWillUpdate-nextState', 'blue'],
['render', 'blue'],
['componentDidUpdate-currentState', 'blue'],
['componentDidUpdate-prevState', 'green'],
['setFavoriteColor', 'blue'],
// forceUpdate()
['componentWillUpdate-currentState', 'blue'],
['componentWillUpdate-nextState', 'blue'],
['render', 'blue'],
['componentDidUpdate-currentState', 'blue'],
['componentDidUpdate-prevState', 'blue'],
['forceUpdate', 'blue'],
// unmountComponent()
// state is available within `componentWillUnmount()`
['componentWillUnmount', 'blue'],
];
expect(stateListener.mock.calls.join('\n')).toEqual(expected.join('\n'));
});
it('should call componentDidUpdate of children first', () => {
var container = document.createElement('div');
var ops = [];
var child = null;
var parent = null;
class Child extends React.Component {
state = {bar: false};
componentDidMount() {
child = this;
}
componentDidUpdate() {
ops.push('child did update');
}
render() {
return <div />;
}
}
var shouldUpdate = true;
class Intermediate extends React.Component {
shouldComponentUpdate() {
return shouldUpdate;
}
render() {
return <Child />;
}
}
class Parent extends React.Component {
state = {foo: false};
componentDidMount() {
parent = this;
}
componentDidUpdate() {
ops.push('parent did update');
}
render() {
return <Intermediate />;
}
}
ReactDOM.render(<Parent />, container);
ReactDOM.unstable_batchedUpdates(() => {
parent.setState({foo: true});
child.setState({bar: true});
});
// When we render changes top-down in a batch, children's componentDidUpdate
// happens before the parent.
expect(ops).toEqual(['child did update', 'parent did update']);
shouldUpdate = false;
ops = [];
ReactDOM.unstable_batchedUpdates(() => {
parent.setState({foo: false});
child.setState({bar: false});
});
// We expect the same thing to happen if we bail out in the middle.
expect(ops).toEqual(['child did update', 'parent did update']);
});
it('should batch unmounts', () => {
var outer;
class Inner extends React.Component {
render() {
return <div />;
}
componentWillUnmount() {
// This should get silently ignored (maybe with a warning), but it
// shouldn't break React.
outer.setState({showInner: false});
}
}
class Outer extends React.Component {
state = {showInner: true};
render() {
return <div>{this.state.showInner && <Inner />}</div>;
}
}
var container = document.createElement('div');
outer = ReactDOM.render(<Outer />, container);
expect(() => {
ReactDOM.unmountComponentAtNode(container);
}).not.toThrow();
});
it('should update state when called from child cWRP', function() {
const log = [];
class Parent extends React.Component {
state = {value: 'one'};
render() {
log.push('parent render ' + this.state.value);
return <Child parent={this} value={this.state.value} />;
}
}
let updated = false;
class Child extends React.Component {
componentWillReceiveProps() {
if (updated) {
return;
}
log.push('child componentWillReceiveProps ' + this.props.value);
this.props.parent.setState({value: 'two'});
log.push('child componentWillReceiveProps done ' + this.props.value);
updated = true;
}
render() {
log.push('child render ' + this.props.value);
return <div>{this.props.value}</div>;
}
}
var container = document.createElement('div');
ReactDOM.render(<Parent />, container);
ReactDOM.render(<Parent />, container);
expect(log).toEqual([
'parent render one',
'child render one',
'parent render one',
'child componentWillReceiveProps one',
'child componentWillReceiveProps done one',
'child render one',
'parent render two',
'child render two',
]);
});
it('should merge state when sCU returns false', function() {
const log = [];
class Test extends React.Component {
state = {a: 0};
render() {
return null;
}
shouldComponentUpdate(nextProps, nextState) {
log.push(
'scu from ' +
Object.keys(this.state) +
' to ' +
Object.keys(nextState),
);
return false;
}
}
const container = document.createElement('div');
const test = ReactDOM.render(<Test />, container);
test.setState({b: 0});
expect(log.length).toBe(1);
test.setState({c: 0});
expect(log.length).toBe(2);
expect(log).toEqual(['scu from a to a,b', 'scu from a,b to a,b,c']);
});
it('should treat assigning to this.state inside cWRP as a replaceState, with a warning', () => {
spyOnDev(console, 'error');
let ops = [];
class Test extends React.Component {
state = {step: 1, extra: true};
componentWillReceiveProps() {
this.setState({step: 2}, () => {
// Tests that earlier setState callbacks are not dropped
ops.push(
`callback -- step: ${this.state.step}, extra: ${!!this.state
.extra}`,
);
});
// Treat like replaceState
this.state = {step: 3};
}
render() {
ops.push(
`render -- step: ${this.state.step}, extra: ${!!this.state.extra}`,
);
return null;
}
}
// Mount
const container = document.createElement('div');
ReactDOM.render(<Test />, container);
// Update
ReactDOM.render(<Test />, container);
expect(ops).toEqual([
'render -- step: 1, extra: true',
'render -- step: 3, extra: false',
'callback -- step: 3, extra: false',
]);
if (__DEV__) {
expect(console.error.calls.count()).toEqual(1);
expect(console.error.calls.argsFor(0)[0]).toEqual(
'Warning: Test.componentWillReceiveProps(): Assigning directly to ' +
"this.state is deprecated (except inside a component's constructor). " +
'Use setState instead.',
);
}
// Check deduplication
ReactDOM.render(<Test />, container);
if (__DEV__) {
expect(console.error.calls.count()).toEqual(1);
}
});
it('should treat assigning to this.state inside cWM as a replaceState, with a warning', () => {
spyOnDev(console, 'error');
let ops = [];
class Test extends React.Component {
state = {step: 1, extra: true};
componentWillMount() {
this.setState({step: 2}, () => {
// Tests that earlier setState callbacks are not dropped
ops.push(
`callback -- step: ${this.state.step}, extra: ${!!this.state
.extra}`,
);
});
// Treat like replaceState
this.state = {step: 3};
}
render() {
ops.push(
`render -- step: ${this.state.step}, extra: ${!!this.state.extra}`,
);
return null;
}
}
// Mount
const container = document.createElement('div');
ReactDOM.render(<Test />, container);
expect(ops).toEqual([
'render -- step: 3, extra: false',
'callback -- step: 3, extra: false',
]);
if (__DEV__) {
expect(console.error.calls.count()).toEqual(1);
expect(console.error.calls.argsFor(0)[0]).toEqual(
'Warning: Test.componentWillMount(): Assigning directly to ' +
"this.state is deprecated (except inside a component's constructor). " +
'Use setState instead.',
);
}
});
});
|
describe('mdCheckbox', function() {
var CHECKED_CSS = 'md-checked';
beforeEach(module('material.components.checkbox'));
beforeEach(module('ngAria'));
beforeEach(TestUtil.mockRaf);
it('should warn developers they need a label', inject(function($compile, $rootScope, $log){
spyOn($log, "warn");
var element = $compile('<div>' +
'<md-checkbox ng-model="blue">' +
'</md-checkbox>' +
'</div>')($rootScope);
expect($log.warn).toHaveBeenCalled();
}));
it('should copy text content to aria-label', inject(function($compile, $rootScope){
var element = $compile('<div>' +
'<md-checkbox ng-model="blue">' +
'Some text' +
'</md-checkbox>' +
'</div>')($rootScope);
var cbElements = element.find('md-checkbox');
expect(cbElements.eq(0).attr('aria-label')).toBe('Some text');
}));
it('should set checked css class and aria-checked attributes', inject(function($compile, $rootScope) {
var element = $compile('<div>' +
'<md-checkbox ng-model="blue">' +
'</md-checkbox>' +
'<md-checkbox ng-model="green">' +
'</md-checkbox>' +
'</div>')($rootScope);
$rootScope.$apply(function(){
$rootScope.blue = false;
$rootScope.green = true;
});
var cbElements = element.find('md-checkbox');
expect(cbElements.eq(0).hasClass(CHECKED_CSS)).toEqual(false);
expect(cbElements.eq(1).hasClass(CHECKED_CSS)).toEqual(true);
expect(cbElements.eq(0).attr('aria-checked')).toEqual('false');
expect(cbElements.eq(1).attr('aria-checked')).toEqual('true');
expect(cbElements.eq(0).attr('role')).toEqual('checkbox');
}));
it('should be disabled with disabled attr', inject(function($compile, $rootScope) {
var element = $compile('<div>' +
'<md-checkbox ng-disabled="isDisabled" ng-model="blue">' +
'</md-checkbox>' +
'</div>')($rootScope);
var checkbox = element.find('md-checkbox');
$rootScope.$apply('isDisabled = true');
$rootScope.$apply('blue = false');
checkbox.triggerHandler('click');
expect($rootScope.blue).toBe(false);
$rootScope.$apply('isDisabled = false');
checkbox.triggerHandler('click');
expect($rootScope.blue).toBe(true);
}));
describe('ng core checkbox tests', function() {
var inputElm;
var scope;
var $compile;
beforeEach(inject(function(_$compile_, _$rootScope_) {
scope = _$rootScope_;
$compile = _$compile_;
}));
function compileInput(html) {
inputElm = $compile(html)(scope);
}
function isChecked(cbEl) {
return cbEl.hasClass(CHECKED_CSS);
}
it('should format booleans', function() {
compileInput('<md-checkbox ng-model="name" />');
scope.$apply("name = false");
expect(isChecked(inputElm)).toBe(false);
scope.$apply("name = true");
expect(isChecked(inputElm)).toBe(true);
});
it('should support type="checkbox" with non-standard capitalization', function() {
compileInput('<md-checkbox ng-model="checkbox" />');
inputElm.triggerHandler('click');
expect(scope.checkbox).toBe(true);
inputElm.triggerHandler('click');
expect(scope.checkbox).toBe(false);
});
it('should allow custom enumeration', function() {
compileInput('<md-checkbox ng-model="name" ng-true-value="\'y\'" ' +
'ng-false-value="\'n\'">');
scope.$apply("name = 'y'");
expect(isChecked(inputElm)).toBe(true);
scope.$apply("name = 'n'");
expect(isChecked(inputElm)).toBe(false);
scope.$apply("name = 'something else'");
expect(isChecked(inputElm)).toBe(false);
inputElm.triggerHandler('click');
expect(scope.name).toEqual('y');
inputElm.triggerHandler('click');
expect(scope.name).toEqual('n');
});
it('should throw if ngTrueValue is present and not a constant expression', function() {
expect(function() {
compileInput('<md-checkbox ng-model="value" ng-true-value="yes" />');
}).toThrow();
});
it('should throw if ngFalseValue is present and not a constant expression', function() {
expect(function() {
compileInput('<md-checkbox ng-model="value" ng-false-value="no" />');
}).toThrow();
});
it('should not throw if ngTrueValue or ngFalseValue are not present', function() {
expect(function() {
compileInput('<md-checkbox ng-model="value" />');
}).not.toThrow();
});
it('should be required if false', function() {
compileInput('<md-checkbox ng:model="value" required />');
inputElm.triggerHandler('click');
expect(isChecked(inputElm)).toBe(true);
expect(inputElm.hasClass('ng-valid')).toBe(true);
inputElm.triggerHandler('click');
expect(isChecked(inputElm)).toBe(false);
expect(inputElm.hasClass('ng-invalid')).toBe(true);
});
});
});
|
// @flow
// Same file as test.js in the root directory.
// This tests that the paths really are root-relative
// These exist in both user code and node_modules, but user code wins
import ambiguous from 'ambiguous';
(ambiguous: empty)
import sub_ambiguous from 'subdir/ambiguous';
(sub_ambiguous: empty)
// These exist in only user code
import user_code from 'user_code';
(user_code: empty)
import sub_user_code from 'subdir/user_code';
(sub_user_code: empty)
// These exist in only node code
import node_code from 'node_code';
(node_code: empty)
import sub_node_code from 'subdir/node_code';
(sub_node_code: empty)
// These exist nowhere
import nonexistent from 'nonexistent'
import sub_nonexistent from 'subdir/nonexistent'
|
// @flow
import * as React from "react";
import { getDisplayName } from "./utils";
import withPhenomicApi from "./withPhenomicApi";
export default function deprecatedCreateContainer<P>(
ComposedComponent: React.ComponentType<P>,
getQueries: (props: Object) => Object = () => ({}),
) {
const displayName = getDisplayName(ComposedComponent);
console.warn(
"`createContainer` has been renamed to `withPhenomicApi`. You can just replace this and this warning will go away (you can import the new name from the same place as before), in " +
displayName,
);
return withPhenomicApi(ComposedComponent, getQueries);
}
|
/*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for
* license information.
*
* Code generated by Microsoft (R) AutoRest Code Generator.
* Changes may cause incorrect behavior and will be lost if the code is
* regenerated.
*/
'use strict';
/**
* Class representing a PetAP.
*/
class PetAP {
/**
* Create a PetAP.
* @member {number} id
* @member {string} [name]
* @member {boolean} [status]
* @member {string} odatalocation
* @member {object} [additionalProperties1]
*/
constructor() {
}
/**
* Defines the metadata of PetAP
*
* @returns {object} metadata of PetAP
*
*/
mapper() {
return {
required: false,
serializedName: 'PetAP',
type: {
name: 'Composite',
additionalProperties: {
type: {
name: 'Dictionary',
value: {
required: false,
serializedName: 'StringElementType',
type: {
name: 'String'
}
}
}
},
className: 'PetAP',
modelProperties: {
id: {
required: true,
serializedName: 'id',
type: {
name: 'Number'
}
},
name: {
required: false,
serializedName: 'name',
type: {
name: 'String'
}
},
eyeColor: {
required: true,
serializedName: 'eyeColor',
isConstant: true,
defaultValue: 'brown',
type: {
name: 'String'
}
},
status: {
required: false,
readOnly: true,
serializedName: 'status',
type: {
name: 'Boolean'
}
},
odatalocation: {
required: true,
serializedName: '@odata\\.location',
type: {
name: 'String'
}
},
additionalProperties1: {
required: false,
serializedName: 'additionalProperties',
type: {
name: 'Dictionary',
value: {
required: false,
serializedName: 'NumberElementType',
type: {
name: 'Number'
}
}
}
}
}
}
};
}
}
module.exports = PetAP;
|
'use strict';
var helper = require('./helper');
module.exports = helper(
'{{Infobox settlement ' +
'| name = Bemowo' +
'|}}'
);
|
describe('button specs', function () {
describe('given a named button at the same bindContext as the viewmodel containing the matching action', function () {
var vm, view, buttonId;
beforeEach(function () {
buttonId = Ext.id();
testNs = {
viewmodels:{
buttonTester:{
go:jasmine.createSpy('go command')
}
},
views:{
buttonTester:{
tbar:[
{
id:buttonId,
text:'Go',
name:'go'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'buttonTester'
});
view = glu.view(vm, 'testNs', 'buttonTester');
});
describe('when a user clicks the button', function () {
beforeEach(function () {
exthelper.click(buttonId);
});
it('The corresponding action should fire', function () {
expect(vm.go).toHaveBeenCalled();
});
});
});
describe('given a named button whose command is further up the model chain', function () {
var vm, view, buttonId;
beforeEach(function () {
buttonId = Ext.id();
testNs = {
viewmodels:{
portal:{
go:jasmine.createSpy('top level go action'),
children:{
mtype:'viewmodelactivator',
autoParent:true,
items:[
{
mtype:'buttonTester'
}
]
}
},
buttonTester:{
}
},
views:{
portal:{
xtype:'tabpanel',
name:'children'
},
buttonTester:{
tbar:[
{
id:buttonId,
text:'Go Again',
name:'go'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'portal'
});
view = glu.view(vm, 'testNs', 'portal');
});
describe('when a user clicks the button', function () {
beforeEach(function () {
exthelper.click(buttonId);
});
it('The corresponding action should fire', function () {
expect(vm.go).toHaveBeenCalled();
});
});
});
describe('given a named button with multiple matching actions up the model chain', function () {
var vm, view, buttonId;
beforeEach(function () {
buttonId = Ext.id();
testNs = {
viewmodels:{
portal:{
go:jasmine.createSpy('top level go action'),
children:{
mtype:'viewmodelactivator',
items:[
{
mtype:'buttonTester'
}
]
}
},
buttonTester:{
go:jasmine.createSpy('lower level go action')
}
},
views:{
portal:{
xtype:'tabpanel',
name:'children'
},
buttonTester:{
tbar:[
{
id:buttonId,
text:'Go Again',
name:'go'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'portal'
});
view = glu.view(vm, 'testNs', 'portal');
});
describe('when a user clicks the button', function () {
beforeEach(function () {
exthelper.click(buttonId);
});
it('Only the first action should fire', function () {
expect(vm.go).wasNotCalled();
expect(vm.children.getAt(0).go).toHaveBeenCalled();
});
});
});
describe('given a named button with a value', function () {
var vm, view, buttonId;
beforeEach(function () {
buttonId = Ext.id();
testNs = {
viewmodels:{
buttonTester:{
go:jasmine.createSpy()
}
},
views:{
buttonTester:{
tbar:[
{
id:buttonId,
text:'Go',
name:'go',
value:'fast'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'buttonTester'
});
view = glu.view(vm, 'testNs', 'buttonTester');
});
describe('when a user clicks the button', function () {
beforeEach(function () {
exthelper.click(buttonId);
});
it('The corresponding action should fire with the passed value', function () {
expect(vm.go.mostRecentCall.args[0]).toEqual('fast');
});
});
});
describe('given a toggle button with pressed bound to a boolean variable', function () {
var vm, view, buttonId;
beforeEach(function () {
buttonId = Ext.id();
testNs = {
viewmodels:{
buttonTester:{
isHappy:true
}
},
views:{
buttonTester:{
tbar:[
{
id:buttonId,
text:'Happy',
enableToggle:true,
pressed:'@{isHappy}'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'buttonTester'
});
view = glu.view(vm, 'testNs', 'buttonTester');
});
it('the button should begin pressed', function () {
expect(Ext.getCmp(buttonId).pressed).toEqual(true);
});
describe('when a user clicks the button and "untoggles" it', function () {
beforeEach(function () {
exthelper.click(buttonId);
});
it('The corresponding property should no longer be true', function () {
expect(vm.get('isHappy')).toEqual(false);
});
});
describe('when the bound propery changes, expect button to be "untoggled"', function () {
beforeEach(function () {
vm.set('isHappy', false);
});
it('The corresponding property should no longer be true', function () {
expect(Ext.getCmp(buttonId).pressed).toEqual(false);
});
});
});
describe('given a named button with a guard action', function () {
var vm, view, buttonId;
function standUp(initialGuardValue) {
buttonId = Ext.id();
testNs = {
viewmodels:{
buttonTester:{
go:jasmine.createSpy('go command'),
goIsEnabled:initialGuardValue
}
},
views:{
buttonTester:{
tbar:[
{
id:buttonId,
name:'go'
}
]
}
}
};
vm = glu.model({
ns:'testNs',
mtype:'buttonTester'
});
view = glu.view(vm, 'testNs', 'buttonTester');
}
;
describe('and the guard property starts off as false (disabled)', function () {
beforeEach(function () {
standUp(false);
});
it('the button should begin disabled', function () {
expect(Ext.getCmp(buttonId).disabled).toEqual(true);
});
describe('when the guard property becomes true', function () {
beforeEach(function () {
vm.set('goIsEnabled', true);
});
it('The button should become enabled', function () {
expect(Ext.getCmp(buttonId).disabled).toEqual(false);
});
})
});
describe('and the guard property starts off as true (enabled)', function () {
beforeEach(function () {
standUp(true);
});
it('the button should begin enabled', function () {
expect(Ext.getCmp(buttonId).disabled).toEqual(false);
});
describe('when the guard property becomes false', function () {
beforeEach(function () {
vm.set('goIsEnabled', false);
});
it('The button should become disabled', function () {
expect(Ext.getCmp(buttonId).disabled).toEqual(true);
});
})
});
});
});
|
/**
* ion-events.js
*
* Author: Max Lynch <max@drifty.com>
*
* Framework events handles various mobile browser events, and
* detects special events like tap/swipe/etc. and emits them
* as custom events that can be used in an app.
*
* Portions lovingly adapted from github.com/maker/ratchet and github.com/alexgibson/tap.js - thanks guys!
*/
(function(ionic) {
// Custom event polyfill
if(!window.CustomEvent) {
(function() {
var CustomEvent;
CustomEvent = function(event, params) {
var evt;
params = params || {
bubbles: false,
cancelable: false,
detail: undefined
};
try {
evt = document.createEvent("CustomEvent");
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
} catch (error) {
// fallback for browsers that don't support createEvent('CustomEvent')
evt = document.createEvent("Event");
for (var param in params) {
evt[param] = params[param];
}
evt.initEvent(event, params.bubbles, params.cancelable);
}
return evt;
};
CustomEvent.prototype = window.Event.prototype;
window.CustomEvent = CustomEvent;
})();
}
/**
* @ngdoc utility
* @name ionic.EventController
* @module ionic
*/
ionic.EventController = {
VIRTUALIZED_EVENTS: ['tap', 'swipe', 'swiperight', 'swipeleft', 'drag', 'hold', 'release'],
/**
* @ngdoc method
* @name ionic.EventController#trigger
* @alias ionic.trigger
* @param {string} eventType The event to trigger.
* @param {object} data The data for the event. Hint: pass in
* `{target: targetElement}`
* @param {boolean=} bubbles Whether the event should bubble up the DOM.
* @param {boolean=} cancelable Whether the event should be cancelable.
*/
// Trigger a new event
trigger: function(eventType, data, bubbles, cancelable) {
var event = new CustomEvent(eventType, {
detail: data,
bubbles: !!bubbles,
cancelable: !!cancelable
});
// Make sure to trigger the event on the given target, or dispatch it from
// the window if we don't have an event target
data && data.target && data.target.dispatchEvent(event) || window.dispatchEvent(event);
},
/**
* @ngdoc method
* @name ionic.EventController#on
* @alias ionic.on
* @description Listen to an event on an element.
* @param {string} type The event to listen for.
* @param {function} callback The listener to be called.
* @param {DOMElement} element The element to listen for the event on.
*/
on: function(type, callback, element) {
var e = element || window;
// Bind a gesture if it's a virtual event
for(var i = 0, j = this.VIRTUALIZED_EVENTS.length; i < j; i++) {
if(type == this.VIRTUALIZED_EVENTS[i]) {
var gesture = new ionic.Gesture(element);
gesture.on(type, callback);
return gesture;
}
}
// Otherwise bind a normal event
e.addEventListener(type, callback);
},
/**
* @ngdoc method
* @name ionic.EventController#off
* @alias ionic.off
* @description Remove an event listener.
* @param {string} type
* @param {function} callback
* @param {DOMElement} element
*/
off: function(type, callback, element) {
element.removeEventListener(type, callback);
},
/**
* @ngdoc method
* @name ionic.EventController#onGesture
* @alias ionic.onGesture
* @description Add an event listener for a gesture on an element.
*
* Available eventTypes (from [hammer.js](http://eightmedia.github.io/hammer.js/)):
*
* `hold`, `tap`, `doubletap`, `drag`, `dragstart`, `dragend`, `dragup`, `dragdown`, <br/>
* `dragleft`, `dragright`, `swipe`, `swipeup`, `swipedown`, `swipeleft`, `swiperight`, <br/>
* `transform`, `transformstart`, `transformend`, `rotate`, `pinch`, `pinchin`, `pinchout`, </br>
* `touch`, `release`
*
* @param {string} eventType The gesture event to listen for.
* @param {function(e)} callback The function to call when the gesture
* happens.
* @param {DOMElement} element The angular element to listen for the event on.
*/
onGesture: function(type, callback, element) {
var gesture = new ionic.Gesture(element);
gesture.on(type, callback);
return gesture;
},
/**
* @ngdoc method
* @name ionic.EventController#offGesture
* @alias ionic.offGesture
* @description Remove an event listener for a gesture on an element.
* @param {string} eventType The gesture event.
* @param {function(e)} callback The listener that was added earlier.
* @param {DOMElement} element The element the listener was added on.
*/
offGesture: function(gesture, type, callback) {
gesture.off(type, callback);
},
handlePopState: function(event) {
},
};
// Map some convenient top-level functions for event handling
ionic.on = function() { ionic.EventController.on.apply(ionic.EventController, arguments); };
ionic.off = function() { ionic.EventController.off.apply(ionic.EventController, arguments); };
ionic.trigger = ionic.EventController.trigger;//function() { ionic.EventController.trigger.apply(ionic.EventController.trigger, arguments); };
ionic.onGesture = function() { return ionic.EventController.onGesture.apply(ionic.EventController.onGesture, arguments); };
ionic.offGesture = function() { return ionic.EventController.offGesture.apply(ionic.EventController.offGesture, arguments); };
})(window.ionic);
|
'use strict';
var _getIterator = require('babel-runtime/core-js/get-iterator')['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.querySelector = querySelector;
exports.querySelectorAll = querySelectorAll;
var _cssSelectorParser = require('css-selector-parser');
var cssParser = new _cssSelectorParser.CssSelectorParser();
cssParser.registerAttrEqualityMods('^', '$', '*', '~', '|');
cssParser.registerNestingOperators('>', '+', '~');
/**
* querySelectorHelper interface provides simple processing
* of Element.querySelector method.
*/
/**
*
* @param {Element} element
* @param {string} query
* @return {Element|null}
*/
/** @function
* @param element
* @param query */
function querySelector(element, query) {
var rules = cssParser.parse(query);
var iterator = processElementDeep(element, rules);
var next = iterator.next();
if (next && next.value) {
return next.value;
}
return null;
}
/**
*
* @param {Element} element
* @param {string} query
* @return {Element[]}
*/
/** @function
* @param element
* @param query */
function querySelectorAll(element, query) {
var rules = cssParser.parse(query);
var result = [];
for (var _iterator = processElementDeep(element, rules), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _getIterator(_iterator);;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var _element = _ref;
result.push(_element);
}
return result;
}
/**
* Function processes one element using current rule
*
* @param {HTMLElement} element - element to check
* @param {*} rules - current rules to check against element
* @return {boolean}
* @function
* @param element
* @param rules */
function* processElement(element, rules) {
for (var _iterator2 = element.children, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _getIterator(_iterator2);;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var child = _ref2;
yield* processRules(child, rules);
}
}
/**
* Function processes one element using current rule
*
* @param {HTMLElement} element - element to check
* @param {*} rules - current rules to check against element
* @return {boolean}
* @function
* @param element
* @param rules */
function* processElementDeep(element, rules) {
for (var _iterator3 = element.children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _getIterator(_iterator3);;) {
var _ref3;
if (_isArray3) {
if (_i3 >= _iterator3.length) break;
_ref3 = _iterator3[_i3++];
} else {
_i3 = _iterator3.next();
if (_i3.done) break;
_ref3 = _i3.value;
}
var child = _ref3;
yield* processRules(child, rules);
yield* processElementDeep(child, rules);
}
}
/**
* @param {Element} element
* @param {Object} rules
* @return {boolean}
* @function
* @param element
* @param rules */
function processRules(element, rules) {
if (rules.type === 'selectors') {
return processSelectors(element, rules.selectors);
} else if (rules.type === 'ruleSet') {
return processRule(element, rules.rule);
}
}
/**
* @param {Element} element
* @param {Object} rule
* @return {boolean}
* @function
* @param element
* @param rule */
function processRule(element, rule) {
return processSelectors(element, [{ rule: rule }]);
}
/**
* @param {Element} element
* @param {Object[]} selectors
* @return {boolean}
* @function
* @param element
* @param selectors */
function* processSelectors(element, selectors) {
for (var _iterator4 = selectors, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _getIterator(_iterator4);;) {
var _ref4;
if (_isArray4) {
if (_i4 >= _iterator4.length) break;
_ref4 = _iterator4[_i4++];
} else {
_i4 = _iterator4.next();
if (_i4.done) break;
_ref4 = _i4.value;
}
var selector = _ref4;
var rule = selector.rule;
if (!matchRule(element, rule)) {
continue;
}
if (!rule.hasOwnProperty('rule')) {
yield element;
return;
}
switch (rule.rule.nestingOperator) {
case '+':
var nextElementSibling = element.nextElementSibling;
if (nextElementSibling && matchRule(nextElementSibling, rule.rule)) {
yield nextElementSibling;
}
break;
case '~':
yield* processElement(element.parentNode, { type: 'ruleSet', rule: rule.rule });
break;
case '>':
yield* processElement(element, { type: 'ruleSet', rule: rule.rule });
break;
default:
yield* processElementDeep(element, { type: 'ruleSet', rule: rule.rule });
}
return;
}
}
/** @function
* @param element
* @param rule */function matchRule(element, rule) {
if (rule.hasOwnProperty('tagName') && element.tagName !== rule.tagName) {
return false;
}
if (rule.hasOwnProperty('id') && element.getAttribute('id') !== rule.id) {
return false;
}
if (rule.hasOwnProperty('classNames')) {
if (!rule.classNames.every(function (name) {
return element.classList.contains(name);
})) {
return false;
}
}
if (rule.hasOwnProperty('attrs')) {
if (!rule.attrs.some(function (attr) {
if (!element.hasAttribute(attr.name)) {
return false;
} else if (attr.operator === undefined) {
return true;
}
var value = element.getAttribute(attr.name);
switch (attr.operator) {
case '=':
return value === attr.value;
case '^=':
return value.startsWith(attr.value);
case '$=':
return value.endsWith(attr.value);
case '~=':
var words = value.split(' ');
return words.some(function (word) {
return word === attr.value;
});
case '*=':
return value.indexOf(attr.value) !== -1;
case '|=':
return value === attr.value || value.startsWith(attr.value + '-');
default:
throw new Error('Unsupported attribute operator ' + attr.operator);
}
})) {
return false;
}
}
return true;
}
//# sourceMappingURL=querySelectorHelper.js.map
|
var assert = require('assert')
var util = require('util')
var _ = require('underscore')
function own(obj){
if( obj ) {
var sb = ['{']
for( var p in obj ) {
if( obj.hasOwnProperty(p) && '$'!=p.charAt(p.length-1)) {
sb.push(p)
sb.push('=')
sb.push(obj[p])
sb.push(',')
}
}
sb.push('}')
return sb.join('')
}
else {
return null
}
}
module.exports = function(expected) {
var index = 0
var history = []
var logger = function(date,type) {
history.push(arguments)
var args = Array.prototype.slice.call(arguments)
args.unshift('ASSERTLOG:')
var argstrs = []
args.forEach(function(a){
//require('eyes').inspect(a)
//util.debug('### '+(a?(a+' '+a.$):null))
argstrs.push(null==a?a:
'string'==typeof(a)?a:
'number'==typeof(a)?a:
_.isDate(a)?(a.getTime()%1000000):
a.hasOwnProperty('toString')?''+a:own(a)
//a.$?own(a):
//(require('eyes').inspect(a),JSON.stringify(a))
)
})
util.debug( argstrs.join('\t') )
function check(expecting,found,index) {
if( expecting != found ) {
assert.fail((index?index+': ':'')+expecting+' != '+found)
}
}
var expect = (expected && expected[index]) || null
if( 'string'==typeof(expect) ) {
check(expect,type)
}
else if( null != expect && 0 < expect.length ) {
check(expect[0],type)
for(var i = 1; i < expect.length; i++ ) {
check(expect[i],arguments[i+1],i)
}
}
index++
}
logger.index = function(){ return index }
logger.history = history
logger.len = expected.length
return logger
}
|
import axios from 'axios';
import { csrfToken } from 'lib/helpers/server-context';
export default class BaseAPI {
constructor() {
this.client = null;
}
/** Returns the API client */
getClient() {
if (this.client) return this.client;
const headers = { Accept: 'application/json', 'X-CSRF-Token': csrfToken };
const params = { format: 'json' };
this.client = axios.create({ headers, params });
return this.client;
}
}
|
/* Copyright (c) 2006-2011 by OpenLayers Contributors (see authors.txt for
* full list of contributors). Published under the Clear BSD license.
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the
* full text of the license. */
/**
* @requires OpenLayers/Format/OWSCommon/v1.js
*/
/**
* Class: OpenLayers.Format.OWSCommon.v1_0_0
* Parser for OWS Common version 1.0.0 which can be used by other parsers.
* It is not intended to be used on its own.
*/
OpenLayers.Format.OWSCommon.v1_0_0 = OpenLayers.Class(OpenLayers.Format.OWSCommon.v1, {
/**
* Property: namespaces
* {Object} Mapping of namespace aliases to namespace URIs.
*/
namespaces: {
ows: "http://www.opengis.net/ows/1.0",
xlink: "http://www.w3.org/1999/xlink"
},
/**
* Property: readers
* Contains public functions, grouped by namespace prefix, that will
* be applied when a namespaced node is found matching the function
* name. The function will be applied in the scope of this parser
* with two arguments: the node being read and a context object passed
* from the parent.
*/
readers: {
"ows": OpenLayers.Format.OWSCommon.v1.prototype.readers["ows"]
},
/**
* Property: writers
* As a compliment to the readers property, this structure contains public
* writing functions grouped by namespace alias and named like the
* node names they produce.
*/
writers: {
"ows": OpenLayers.Format.OWSCommon.v1.prototype.writers["ows"]
},
CLASS_NAME: "OpenLayers.Format.OWSCommon.v1_1_0"
});
|
var gulp = require('gulp');
var stylus = require('gulp-stylus');
var rename = require('gulp-rename');
var minifyCSS = require('gulp-minify-css');
var nib = require('nib');
gulp.task('stylus', function () {
return gulp.src('./stylus/index.styl')
.pipe(stylus({use: [nib()]}))
.pipe(minifyCSS())
.pipe(rename('styles.css'))
.pipe(gulp.dest('./assets'));
});
gulp.task('stylus-docs', function () {
return gulp.src('./ui-docs/docs.styl')
.pipe(stylus({use: [nib()]}))
.pipe(gulp.dest('./ui-docs'));
});
gulp.task('stylus-watch', ['stylus'], function () {
gulp.watch('./stylus/**/*.styl', ['stylus', 'stylus-docs']);
});
gulp.task('stylus-watch-docs', ['stylus-docs'], function () {
gulp.watch('./ui-docs/*.styl', ['stylus-docs']);
});
gulp.task('watch', ['stylus-watch', 'stylus-watch-docs']);
gulp.task('default', ['watch']);
|
/**
* Copyright 2012-2017, Plotly, Inc.
* All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict';
var Box = {};
Box.attributes = require('./attributes');
Box.layoutAttributes = require('./layout_attributes');
Box.supplyDefaults = require('./defaults');
Box.supplyLayoutDefaults = require('./layout_defaults');
Box.calc = require('./calc');
Box.setPositions = require('./set_positions');
Box.plot = require('./plot');
Box.style = require('./style');
Box.hoverPoints = require('./hover');
Box.moduleType = 'trace';
Box.name = 'box';
Box.basePlotModule = require('../../plots/cartesian');
Box.categories = ['cartesian', 'symbols', 'oriented', 'box', 'showLegend'];
Box.meta = {
description: [
'In vertical (horizontal) box plots,',
'statistics are computed using `y` (`x`) values.',
'By supplying an `x` (`y`) array, one box per distinct x (y) value',
'is drawn',
'If no `x` (`y`) {array} is provided, a single box is drawn.',
'That box position is then positioned with',
'with `name` or with `x0` (`y0`) if provided.',
'Each box spans from quartile 1 (Q1) to quartile 3 (Q3).',
'The second quartile (Q2) is marked by a line inside the box.',
'By default, the whiskers correspond to the box\' edges',
'+/- 1.5 times the interquartile range (IQR = Q3-Q1),',
'see *boxpoints* for other options.'
].join(' ')
};
module.exports = Box;
|
import { EssentialAppDisabledException } from '@rocket.chat/apps-engine/definition/exceptions';
import { AppInterface } from '@rocket.chat/apps-engine/definition/metadata';
import { AppManager } from '@rocket.chat/apps-engine/server/AppManager';
import { Meteor } from 'meteor/meteor';
import { Logger } from '../../logger';
import { AppsLogsModel, AppsModel, AppsPersistenceModel, Permissions } from '../../models';
import { settings } from '../../settings';
import { RealAppBridges } from './bridges';
import { AppMethods, AppServerNotifier, AppsRestApi, AppUIKitInteractionApi } from './communication';
import { AppMessagesConverter, AppRoomsConverter, AppSettingsConverter, AppUsersConverter } from './converters';
import { AppDepartmentsConverter } from './converters/departments';
import { AppUploadsConverter } from './converters/uploads';
import { AppVisitorsConverter } from './converters/visitors';
import { AppRealLogsStorage, AppRealStorage } from './storage';
function isTesting() {
return process.env.TEST_MODE === 'true';
}
class AppServerOrchestrator {
constructor() {
this._isInitialized = false;
}
initialize() {
this._rocketchatLogger = new Logger('Rocket.Chat Apps');
Permissions.create('manage-apps', ['admin']);
this._marketplaceUrl = 'https://marketplace.rocket.chat';
this._model = new AppsModel();
this._logModel = new AppsLogsModel();
this._persistModel = new AppsPersistenceModel();
this._storage = new AppRealStorage(this._model);
this._logStorage = new AppRealLogsStorage(this._logModel);
this._converters = new Map();
this._converters.set('messages', new AppMessagesConverter(this));
this._converters.set('rooms', new AppRoomsConverter(this));
this._converters.set('settings', new AppSettingsConverter(this));
this._converters.set('users', new AppUsersConverter(this));
this._converters.set('visitors', new AppVisitorsConverter(this));
this._converters.set('departments', new AppDepartmentsConverter(this));
this._converters.set('uploads', new AppUploadsConverter(this));
this._bridges = new RealAppBridges(this);
this._manager = new AppManager(this._storage, this._logStorage, this._bridges);
this._communicators = new Map();
this._communicators.set('methods', new AppMethods(this));
this._communicators.set('notifier', new AppServerNotifier(this));
this._communicators.set('restapi', new AppsRestApi(this, this._manager));
this._communicators.set('uikit', new AppUIKitInteractionApi(this));
this._isInitialized = true;
}
getModel() {
return this._model;
}
getPersistenceModel() {
return this._persistModel;
}
getStorage() {
return this._storage;
}
getLogStorage() {
return this._logStorage;
}
getConverters() {
return this._converters;
}
getBridges() {
return this._bridges;
}
getNotifier() {
return this._communicators.get('notifier');
}
getManager() {
return this._manager;
}
getProvidedComponents() {
return this._manager.getExternalComponentManager().getProvidedComponents();
}
isInitialized() {
return this._isInitialized;
}
isEnabled() {
return settings.get('Apps_Framework_enabled');
}
isLoaded() {
return this.getManager().areAppsLoaded();
}
isDebugging() {
return settings.get('Apps_Framework_Development_Mode') && !isTesting();
}
getRocketChatLogger() {
return this._rocketchatLogger;
}
debugLog(...args) {
if (this.isDebugging()) {
// eslint-disable-next-line
console.log(...args);
}
}
getMarketplaceUrl() {
return this._marketplaceUrl;
}
async load() {
// Don't try to load it again if it has
// already been loaded
if (this.isLoaded()) {
return;
}
return this._manager.load()
.then((affs) => console.log(`Loaded the Apps Framework and loaded a total of ${ affs.length } Apps!`))
.catch((err) => console.warn('Failed to load the Apps Framework and Apps!', err));
}
async unload() {
// Don't try to unload it if it's already been
// unlaoded or wasn't unloaded to start with
if (!this.isLoaded()) {
return;
}
return this._manager.unload()
.then(() => console.log('Unloaded the Apps Framework.'))
.catch((err) => console.warn('Failed to unload the Apps Framework!', err));
}
async updateAppsMarketplaceInfo(apps = []) {
if (!this.isLoaded()) {
return;
}
return this._manager.updateAppsMarketplaceInfo(apps)
.then(() => this._manager.get());
}
async triggerEvent(event, ...payload) {
if (!this.isLoaded()) {
return;
}
return this.getBridges().getListenerBridge().handleEvent(event, ...payload).catch((error) => {
if (error instanceof EssentialAppDisabledException) {
throw new Meteor.Error('error-essential-app-disabled');
}
throw error;
});
}
}
export const AppEvents = AppInterface;
export const Apps = new AppServerOrchestrator();
settings.addGroup('General', function() {
this.section('Apps', function() {
this.add('Apps_Framework_enabled', true, {
type: 'boolean',
hidden: false,
});
this.add('Apps_Framework_Development_Mode', false, {
type: 'boolean',
enableQuery: {
_id: 'Apps_Framework_enabled',
value: true,
},
public: true,
hidden: false,
});
this.add('Apps_Game_Center_enabled', false, {
type: 'boolean',
enableQuery: {
_id: 'Apps_Framework_enabled',
value: true,
},
hidden: false,
public: true,
alert: 'Experimental_Feature_Alert',
});
});
});
settings.get('Apps_Framework_enabled', (key, isEnabled) => {
// In case this gets called before `Meteor.startup`
if (!Apps.isInitialized()) {
return;
}
if (isEnabled) {
Apps.load();
} else {
Apps.unload();
}
});
Meteor.startup(function _appServerOrchestrator() {
Apps.initialize();
if (Apps.isEnabled()) {
Apps.load();
}
});
|
/****************************************************************************
The MIT License (MIT)
Copyright (c) 2013 Apigee Corporation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
'use strict';
var Spi = require('..');
var config = require('../../../testconfig/testconfig').config;
var assert = require('assert');
var _ = require('underscore');
// clone & extend hash
function extend(a, b) {
var reply = _.extend({}, a, b);
disableBuffer(reply); // need to bypass buffer for these tests
return reply;
}
function disableBuffer(options) {
delete(options.bufferSize);
delete(options.bufferTimeout);
}
describe('Quota', function() {
describe('Expiration time', function() {
it('Minute rolling', function() {
var options = extend(config, {
timeUnit: 'minute',
interval: 1,
allow: 5
});
var q = Spi.create(options).quota;
var start = new Date('March 7, 2013 12:00:00');
var end = new Date('March 7, 2013 12:01:00');
var expires = new Date(q.calculateExpiration(start.getTime()));
assert.deepEqual(end, expires);
start = new Date('March 7, 2013 12:00:27');
end = new Date('March 7, 2013 12:01:27');
expires = new Date(q.calculateExpiration(start.getTime()));
assert.deepEqual(end, expires);
q.destroy();
});
it('Minute calendar', function() {
var options = extend(config, {
timeUnit: 'minute',
interval: 1,
allow: 5,
startTime: new Date('March 7, 2013 12:00:00').getTime()
});
var q = Spi.create(options).quota;
// Easy
var now = new Date('March 7, 2013 12:00:00');
var end = new Date('March 7, 2013 12:01:00');
var expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
// Bucket is up in a minute
now = new Date('March 7, 2013 12:00:27');
end = new Date('March 7, 2013 12:01:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
// Some time after the start
now = new Date('October 28, 2013 13:23:00');
end = new Date('October 28, 2013 13:24:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
now = new Date('October 28, 2013 13:23:13');
end = new Date('October 28, 2013 13:24:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
q.destroy();
});
it('Hour rolling', function() {
var options = extend(config, {
timeUnit: 'hour',
interval: 1,
allow: 5
});
var q = Spi.create(options).quota;
var start = new Date('March 7, 2013 12:00:00');
var end = new Date('March 7, 2013 13:00:00');
var expires = new Date(q.calculateExpiration(start.getTime()));
assert.deepEqual(end, expires);
start = new Date('March 7, 2013 12:00:27');
end = new Date('March 7, 2013 13:00:27');
expires = new Date(q.calculateExpiration(start.getTime()));
assert.deepEqual(end, expires);
q.destroy();
});
it('Hour calendar', function() {
var options = extend(config, {
timeUnit: 'hour',
interval: 1,
allow: 5,
startTime: new Date('March 7, 2013 12:00:00').getTime()
});
var q = Spi.create(options).quota;
// Easy
var now = new Date('March 7, 2013 12:00:00');
var end = new Date('March 7, 2013 13:00:00');
var expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
now = new Date('March 7, 2013 12:15:42');
end = new Date('March 7, 2013 13:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
// Some time after the start
now = new Date('October 28, 2013 13:00:00');
end = new Date('October 28, 2013 14:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
now = new Date('October 28, 2013 13:23:13');
end = new Date('October 28, 2013 14:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
q.destroy();
});
it('Day calendar', function() {
var options = extend(config, {
timeUnit: 'day',
interval: 1,
allow: 5,
startTime: new Date('March 7, 2013 12:00:00').getTime()
});
var q = Spi.create(options).quota;
// Easy
var now = new Date('March 7, 2013 12:00:00');
var end = new Date('March 8, 2013 12:00:00');
var expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
now = new Date('March 7, 2013 22:23:24');
end = new Date('March 8, 2013 12:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
// Some time after the start
now = new Date('March 8, 2013 12:00:00');
end = new Date('March 9, 2013 12:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
now = new Date('March 9, 2013 09:10:11');
end = new Date('March 9, 2013 12:00:00');
expires = new Date(q.calculateExpiration(now.getTime()));
assert.deepEqual(end, expires);
q.destroy();
});
});
});
|
/*!
* remark (http://getbootstrapadmin.com/remark)
* Copyright 2015 amazingsurge
* Licensed under the Themeforest Standard Licenses
*/
(function(window, document, $) {
'use strict';
var $body = $('body'),
$html = $('html');
$.site.gridmenu = {
opened: false,
init: function() {
this.$instance = $('.site-gridmenu');
if (this.$instance.length === 0) {
return;
}
this.bind();
},
bind: function() {
var self = this;
$(document).on('click', '[data-toggle="gridmenu"]', function() {
var $this = $(this);
if (self.opened) {
self.close();
$this.removeClass('active')
.attr('aria-expanded', false);
} else {
self.open();
$this.addClass('active')
.attr('aria-expanded', true);
}
});
},
open: function() {
var self = this;
if (this.opened !== true) {
this.animate(function() {
self.opened = true;
self.$instance.addClass('active');
$('[data-toggle="gridmenu"]').addClass('active')
.attr('aria-expanded', true);
$body.addClass('site-gridmenu-active');
$html.addClass('disable-scrolling');
}, function() {
this.scrollable.enable();
});
}
},
close: function() {
var self = this;
if (this.opened === true) {
this.animate(function() {
self.opened = false;
self.$instance.removeClass('active');
$('[data-toggle="gridmenu"]').addClass('active')
.attr('aria-expanded', true);
$body.removeClass('site-gridmenu-active');
$html.removeClass('disable-scrolling');
}, function() {
this.scrollable.disable();
});
}
},
toggle: function() {
if (this.opened) {
this.close();
} else {
this.open();
}
},
animate: function(doing, callback) {
var self = this;
doing.call(self);
this.$instance.trigger('changing.site.gridmenu');
setTimeout(function() {
callback.call(self);
self.$instance.trigger('changed.site.gridmenu');
}, 500);
},
scrollable: {
api: null,
init: function() {
this.api = $.site.gridmenu.$instance.asScrollable({
namespace: 'scrollable',
skin: 'scrollable-inverse',
direction: 'vertical',
contentSelector: '>',
containerSelector: '>'
}).data('asScrollable');
},
update: function() {
if (this.api) {
this.api.update();
}
},
enable: function() {
if (!this.api) {
this.init();
}
if (this.api) {
this.api.enable();
}
},
disable: function() {
if (this.api) {
this.api.disable();
}
}
},
};
})(window, document, jQuery);
|
// jshint undef:true
// jshint eqeqeq:false
/* globals Set */
/* globals getAttrByName */
/* globals findObjs */
/* globals _ */
/* globals createObj */
/* globals log */
/* globals sendChat */
/* globals state */
/* globals Campaign */
/* globals getObj */
/* globals randomInteger */
/* globals spawnFx */
/* globals spawnFxBetweenPoints */
/* globals VecMath */
/* globals on */
/* globals toFront */
/* globals playerIsGM */
/* globals HealthColors */
// Needs the Vector Math scripty
var COF_loaded = false;
var COFantasy = COFantasy || function() {
"use strict";
var PIX_PER_UNIT = 70;
var HISTORY_SIZE = 150;
var eventHistory = [];
var updateNextInitSet = new Set();
var BS_LABEL = 'text-transform: uppercase; display: inline; padding: .2em .6em .3em; font-size: 75%; line-height: 2; color: #fff; text-align: center; white-space: nowrap; vertical-align: baseline; border-radius: .25em;';
var BS_LABEL_DEFAULT = 'background-color: #777;';
var BS_LABEL_PRIMARY = 'background-color: #337ab7;';
var BS_LABEL_SUCCESS = 'background-color: #5cb85c;';
var BS_LABEL_INFO = 'background-color: #5bc0de;';
var BS_LABEL_WARNING = 'background-color: #f0ad4e;';
var BS_LABEL_DANGER = 'background-color: #d9534f;';
var bs_alert = 'padding: 5px; border: 1px solid transparent; border-radius: 4px;';
var bs_alert_success = 'color: #3c763d; background-color: #dff0d8; border-color: #d6e9c6;';
var bs_alert_danger = 'color: #a94442; background-color: #f2dede; border-color: #ebccd1;';
var defaultOptions = {
regles: {
explications: "Options qui influent sur les règles du jeu",
type: 'options',
val: {
blessures_graves: {
explications: "Si les DMs dépassent CON+niveau, ou si on arrive à 0 PV, on perd un PR, et si plus de PR, affaibli.",
val: true,
type: 'bool'
},
dm_minimum: {
explications: "Dégâts minimum d'une attaque ou autre source de DM.",
val: 1,
type: 'int'
},
crit_elementaire: {
explications: "Les DMs constants d'un autre type que celui de l'arme sont aussi multipliés en cas de critique",
val: false,
type: 'bool'
},
forme_d_arbre_amelioree: {
explications: "+50% à l'effet de la peau d'écorce en forme d'arbre.",
val: true,
type: 'bool'
},
initiative_variable: {
explications: "Ajoute 1d6 à l'initiative, lancé une fois par combat",
val: false,
type: 'bool'
},
usure_DEF: {
explications: "Malus de -2 en DEF tous les n tours. Mettre à 0 pour ne pas avoir de malus d'usure",
val: 5,
type: 'int'
},
mana_totale: {
explications: "Tous les sorts ont un coût, celui des tempêtes de mana est multiplié par 3",
val: false,
type: 'bool'
},
elixirs_sorts: {
explications: "Toutes fabrications d'élixir sont considérées comme des sorts (qui peuvent coûter de la mana)",
val: true,
type: 'bool'
},
interchangeable_attaque: {
explications: "La capacité interchangeable donne moins de DEF mais plus d'attaque",
val: true,
type: 'bool'
},
}
},
affichage: {
explications: "Options d'affichage",
type: 'options',
val: {
MJ_voit_actions: {
explications: "À chaque nouveau personnage en combat, montre le choix d'actions au MJ, même pour les PJs.",
val: false,
type: 'bool'
},
avatar_dans_cadres: {
explications: "Si faux, on utilise l'image du token.",
val: true,
type: 'bool'
},
manoeuvres: {
explications: "Affiche les manoeuvres dans la liste d'actions",
val: true,
type: 'bool'
},
actions_par_defaut: {
explications: "Sans ability #Actions#, affiche la liste des abilities",
val: true,
type: 'bool'
},
montre_def: {
explications: "montre la DEF des adversaires dans les cadres de combat",
val: true,
type: 'bool'
},
fiche: {
explications: "La fiche interagit avec le script",
val: true,
type: 'bool'
},
}
},
images: {
explications: "Images par défaut",
type: 'options',
val: {
image_double: {
explications: 'Image utilisée pour la capacité dédoublement',
type: 'image',
val: "https://s3.amazonaws.com/files.d20.io/images/33854984/q10B3KtWsCxcMczLo4BSUw/thumb.png?1496303265"
},
image_ombre: {
explications: "Image utilisée pour l'ombre mortelle",
type: 'image',
val: "https://s3.amazonaws.com/files.d20.io/images/2781735/LcllgIHvqvu0HAbWdXZbJQ/thumb.png?13900368485"
},
image_arbre: {
explications: "Image utilisée pour la forme d'arbre",
type: 'image',
val: "https://s3.amazonaws.com/files.d20.io/images/52767134/KEGYUXeKnxZr5dbDwQEO4Q/thumb.png?15248300835"
},
image_mur_de_force: {
explication: "Image utilisée pour un mur de force sphérique",
type: 'image',
val: "https://s3.amazonaws.com/files.d20.io/images/33213510/5r3NGSso1QBJMJewTEKv0A/thumb.png?1495195634"
},
}
},
macros_à_jour: {
explications: "Met automatiquement les macros à jour",
type: 'bool',
val: true
}
};
function copyOptions(dst, src) {
for (var o in src) {
var opt = src[o];
var isOption = opt.type == 'options';
if (dst[o] === undefined) {
dst[o] = {
explications: opt.explications,
val: {},
type: opt.type,
};
if (!isOption) dst[o].val = opt.val;
}
if (isOption) copyOptions(dst[o].val, opt.val);
}
}
var aura_token_on_turn = false;
var stateCOF = state.COFantasy;
function setStateCOF() {
stateCOF = state.COFantasy;
if (stateCOF.options === undefined) stateCOF.options = {};
copyOptions(stateCOF.options, defaultOptions);
if (stateCOF.options.macros_à_jour.val) {
var macros = findObjs({
_type: 'macro'
});
var players = findObjs({
_type: 'player'
});
var mjs = [];
players.forEach(function(p) {
if (playerIsGM(p.id)) mjs.push(p.id);
});
var inBar = [];
if (stateCOF.gameMacros) {
//Check modified or removed macros
stateCOF.gameMacros.forEach(function(gm) {
var ngm = gameMacros.find(function(ngm) {
return ngm.name == gm.name;
});
if (ngm) {
if (ngm.action == gm.action && ngm.visibleto == gm.visibleto && ngm.istokenaction == gm.istokenaction) return;
macros.forEach(function(m) {
if (m.get('name') != ngm.name) return;
if (ngm.action != gm.action && m.get('action') == gm.action)
m.set('action', ngm.action);
if (ngm.visibleto != gm.visibleto && m.get('visibleto') == gm.visibleto)
m.set('visibleto', ngm.visibleto);
if (ngm.istokenaction != gm.istokenaction && m.get('istokenaction') == gm.istokenaction)
m.set('istokenaction', ngm.istokenaction);
sendChat('COF', '/w GM Macro ' + ngm.name + ' mise à jour.');
});
} else {
macros.forEach(function(m) {
if (m.get('name') != gm.name) return;
if (m.get('action') != gm.action) return;
m.remove();
sendChat('COF', '/w GM Macro ' + ngm.name + ' effacée.');
});
}
});
//Nouvelles macros
gameMacros.forEach(function(ngm) {
var gm = stateCOF.gameMacros.find(function(gm) {
return ngm.name == gm.name;
});
if (!gm) {
var prev =
macros.find(function(macro) {
return macro.get('name') == ngm.name;
});
if (prev === undefined) {
sendChat('COF', '/w GM Macro ' + ngm.name + ' créée.');
if (ngm.inBar) inBar.push(ngm.name);
mjs.forEach(function(playerId, i) {
if (i === 0 || ngm.visibleto === '') {
ngm.playerid = playerId;
createObj('macro', ngm);
}
});
}
}
});
} else {
//Peut-être la première fois, vérifier les macros
if (stateCOF.macros) {
//ancienne version, et on avait copié les macros
//on enlève juste Escalier, et on remplace par Monter et Descendre
var mesc = macros.find(function(m) {
return m.get('name') == 'Escalier';
});
if (mesc) {
createObj({
name: 'Monter',
action: "!cof-escalier",
visibleto: '',
istokenaction: true,
inBar: false,
_playerid: mesc.playerid
});
createObj({
name: 'Descendre',
action: "!cof-escalier bas",
visibleto: '',
istokenaction: true,
inBar: false,
_playerid: mesc.playerid
});
mesc.remove();
}
} else {
gameMacros.forEach(function(m) {
var prev =
macros.find(function(macro) {
return macro.get('name') == m.name;
});
if (prev === undefined) {
sendChat('COF', '/w GM Macro ' + m.name + ' créée.');
if (m.inBar) inBar.push(m.name);
mjs.forEach(function(playerId, i) {
if (i === 0 || m.visibleto === '') {
m.playerid = playerId;
createObj('macro', m);
}
});
}
});
}
}
if (inBar.length > 0) {
sendChat('COF', "/w GM Macros à mettre dans la barre d'action du MJ : " + inBar.join(', '));
}
stateCOF.gameMacros = gameMacros;
}
}
// List of states:
var cof_states = {
assome: 'status_pummeled',
mort: 'status_dead',
surpris: 'status_lightning-helix',
renverse: 'status_back-pain',
aveugle: 'status_bleeding-eye',
affaibli: 'status_half-heart',
etourdi: 'status_half-haze',
paralyse: 'status_fishing-net',
ralenti: 'status_snail',
immobilise: 'status_cobweb',
endormi: 'status_sleepy',
apeure: 'status_screaming',
invisible: 'status_ninja-mask',
blessé: 'status_arrowed',
encombre: 'status_frozen-orb'
};
function etatRendInactif(etat) {
var res =
etat == 'mort' || etat == 'surpris' || etat == 'assome' ||
etat == 'etourdi' || etat == 'paralyse' || etat == 'endormi' ||
etat == 'apeure';
return res;
}
function error(msg, obj) {
log(msg);
log(obj);
sendChat("COFantasy", msg);
}
// retourne un tableau contenant la liste des ID de joueurs connectés controlant le personnage lié au Token
function getPlayerIds(perso) {
var character = getObj('character', perso.charId);
if (character === undefined) return;
var charControlledby = character.get('controlledby');
if (charControlledby === '') return [];
var playerIds = [];
charControlledby.split(",").forEach(function(controlledby) {
var player = getObj('player', controlledby);
if (player === undefined) return;
if (player.get('online')) playerIds.push(controlledby);
});
return playerIds;
}
function persoEstPNJ(perso) {
if (perso.pnj) return true;
var typePerso = getAttrByName(perso.charId, 'type_personnage');
return typePerso == 'PNJ';
}
var attackNameRegExp = new RegExp(/^(repeating_armes_.*_)armenom$/);
var attackNamePNJRegExp = new RegExp(/^(repeating_pnj.*_)armenom$/);
//Met perso.pnj à true si on a un PNJ
function getAttack(attackLabel, perso) {
var res;
var attributes = findObjs({
_type: 'attribute',
_characterid: perso.charId,
});
var findAttack = function(n) {
return attackNameRegExp.exec(n);
};
if (perso.pnj) {
findAttack = function(n) {
return attackNamePNJRegExp.exec(n);
};
}
var trouve;
attributes.forEach(function(a) {
if (trouve) return;
if (a.get('name').toLowerCase() == 'type_personnage') {
trouve = true;
if (a.get('current') == 'PNJ') {
perso.pnj = true;
findAttack = function(n) {
return attackNamePNJRegExp.exec(n);
};
}
}
});
attributes.forEach(function(a) {
if (res) return;
var an = a.get('name');
var m = findAttack(an);
if (m) {
var attPrefix = m[1];
var weaponName = a.get('current');
if (weaponName === undefined || weaponName === "") {
error("Pas de nom pour une attaque");
return;
}
var weaponLabel = weaponName.split(' ', 1)[0];
if (weaponLabel == attackLabel) {
weaponName = weaponName.substring(weaponName.indexOf(' ') + 1);
res = {
attackPrefix: attPrefix,
weaponName: weaponName
};
}
}
});
return res;
}
function getPictoStyleFromCommand(fullCommand, perso) {
if (fullCommand === undefined) return {
picto: '',
style: ''
};
var style = '';
var picto = '';
var command = fullCommand.split(' ');
// Pictos : https://wiki.roll20.net/CSS_Wizardry#Pictos
switch (command[0]) {
case "#Attaque":
case "!cof-attack":
case "!cof-attaque":
var portee = 0;
if (command.length > 3) {
var attackLabel = command[3];
if (!attackLabel.startsWith('?')) {
var att = getAttack(attackLabel, perso);
if (att !== undefined) {
portee = getPortee(perso.charId, att.attackPrefix);
} else {
var thisWeapon = [];
try {
thisWeapon = JSON.parse(attackLabel);
if (Array.isArray(thisWeapon) && thisWeapon.length > 4) {
portee = thisWeapon[4];
}
} catch (e) {
log("Impossible de trouver la portée pour " + attackLabel);
}
}
}
}
if (fullCommand.indexOf('--sortileg') !== -1) {
// attaque magique
picto = '<span style="font-family: \'Pictos Three\'">g</span> ';
style = 'background-color:#9900ff';
} else if (portee > 0) {
// attaque distance
picto = '<span style="font-family: \'Pictos Custom\'">[</span> ';
style = 'background-color:#48b92c';
} else {
// attaque contact
picto = '<span style="font-family: \'Pictos Custom\'">t</span> ';
style = 'background-color:#cc0000';
}
break;
case "!cof-lancer-sort":
case "!cof-injonction":
picto = '<span style="font-family: \'Pictos Three\'">g</span> ';
style = 'background-color:#9900ff';
break;
case "!cof-soin":
case "!cof-transe-guerison":
case "!cof-delivrance":
case "!cof-guerir":
picto = '<span style="font-family: \'Pictos\'">k</span> ';
style = 'background-color:#ffe599;color:#333';
break;
case "!cof-effet":
case "!cof-effet-temp":
case "!cof-effet-combat":
picto = '<span style="font-family: \'Pictos\'">S</span> ';
style = 'background-color:#4a86e8';
break;
case "!cof-enduire-poison":
picto = '<span style="font-family: \'Pictos Three\'">i</span> ';
style = 'background-color:#05461c';
break;
case "!cof-desarmer":
picto = '<span style="font-family: \'Pictos Custom\'">t</span> ';
style = 'background-color:#cc0000';
break;
case "!cof-surprise":
picto = '<span style="font-family: \'Pictos\'">e</span> ';
style = 'background-color:#4a86e8';
break;
case "!cof-recharger":
picto = '<span style="font-family: \'Pictos\'">0</span> ';
style = 'background-color:#e69138';
break;
case "!cof-action-defensive":
picto = '<span style="font-family: \'Pictos Three\'">b</span> ';
style = 'background-color:#cc0000';
break;
case "!cof-manoeuvre":
picto = '<span style="font-family: \'Pictos Three\'">d</span> ';
style = 'background-color:#cc0000';
break;
case "!cof-attendre":
picto = '<span style="font-family: \'Pictos\'">t</span> ';
style = 'background-color:#999999';
break;
case "!cof-aoe": //deprecated
case "!cof-dmg":
picto = '<span style="font-family: \'Pictos\'">\'</span> ';
style = 'background-color:#cc0000';
break;
case "!cof-peur":
picto = '<span style="font-family: \'Pictos\'">`</span> ';
style = 'background-color:#B445FE';
break;
case "!cof-consommables":
picto = '<span style="font-family: \'Pictos\'">b</span> ';
style = 'background-color:#ce0f69';
break;
case "!cof-liste-actions":
picto = '<span style="font-family: \'Pictos\'">l</span> ';
style = 'background-color:#272751';
break;
default:
picto = '';
style = '';
}
return {
picto: picto,
style: style
};
}
function getState(personnage, etat) {
var token = personnage.token;
var charId = personnage.charId;
var res = false;
if (token !== undefined) {
res = token.get(cof_states[etat]);
if (token.get('bar1_link') === "") return res;
// else, look for the character value, if any
if (charId === undefined) charId = token.get('represents');
}
if (charId === "") {
error("token with a linked bar1 but representing no character", token);
return false;
}
if (etat == 'affaibli') { //special case due to new character sheet
var de = parseInt(getAttrByName(charId, 'ETATDE'));
if (de === 20) {
if (res && token !== undefined) token.set(cof_states[etat], false);
return false;
} else if (de === 12) {
if (!res && token !== undefined) token.set(cof_states[etat], true);
return true;
}
}
var attr = findObjs({
_type: 'attribute',
_characterid: charId,
name: etat
});
if (attr.length === 0) {
if (res && token !== undefined) token.set(cof_states[etat], false);
return false;
}
if (!res && token !== undefined) token.set(cof_states[etat], true);
return true;
}
//Met le champ field à value du token dans evt, pour permettre le undo
function affectToken(token, field, value, evt) {
evt.affectes = evt.affectes || {};
var aff = evt.affectes[token.id];
if (aff === undefined) {
aff = {
affecte: token,
prev: {}
};
evt.affectes[token.id] = aff;
}
if (aff.prev[field] === undefined) aff.prev[field] = value;
return aff;
}
function estAffaibli(perso) {
if (getState(perso, 'affaibli')) return true;
if (getState(perso, 'blessé')) return true;
return false;
}
function setToken(token, field, newValue, evt) {
var prevValue = token.get(field);
affectToken(token, field, prevValue, evt);
token.set(field, newValue);
}
function isActive(perso) {
var inactif =
getState(perso, 'mort') || getState(perso, 'surpris') ||
getState(perso, 'assome') || getState(perso, 'etourdi') ||
getState(perso, 'paralyse') || getState(perso, 'endormi') ||
getState(perso, 'apeure') || attributeAsBool(perso, 'statueDeBois');
return !inactif;
}
function sendChar(charId, msg) {
var dest = '';
if (charId) dest = 'character|' + charId;
sendChat(dest, msg);
}
//Chuchote le message à tous les joueurs présents qui controllent le
//personnage, plus le MJ
function whisperChar(charId, msg) {
var character = getObj('character', charId);
if (character) {
var controlled = character.get('controlledby');
if (controlled.includes('all')) sendChar(charId, msg);
else {
controlled.split(',').forEach(function(c) {
if (c !== '' && !playerIsGM(c)) {
var p = getObj('player', c);
if (p && p.get('online')) {
sendChar(charId, '/w "' + p.get('_displayname') + '" ' + msg);
}
}
});
sendChar(charId, "/w GM " + msg);
}
} else {
sendChar(charId, "/w GM " + msg);
}
}
// options: bonus:int, deExplosif:bool
//Renvoie 1dk + bonus, avec le texte
//champs val et roll
function rollDePlus(de, options) {
options = options || {};
var bonus = options.bonus || 0;
var explose = options.deExplosif || false;
var texteJetDeTotal = '';
var jetTotal = 0;
do {
var jetDe = randomInteger(de);
texteJetDeTotal += jetDe;
jetTotal += jetDe;
explose = explose && (jetDe === de);
if (explose) texteJetDeTotal += ',';
} while (explose && jetTotal < 1000);
var res = {
val: jetTotal + bonus
};
var msg = '<span style="display: inline-block; border-radius: 5px; padding: 0 4px; background-color: #F1E6DA; color: #000;" title="1d';
msg += de;
if (options.deExplosif) msg += '!';
if (bonus > 0) {
msg += '+' + bonus;
texteJetDeTotal += '+' + bonus;
} else if (bonus < 0) {
msg += bonus;
texteJetDeTotal += bonus;
}
msg += ' = ' + texteJetDeTotal + '" class="a inlinerollresult showtip tipsy-n">';
msg += res.val + "</span>";
res.roll = msg;
return res;
}
function setTokenAttr(personnage, attribute, value, evt, msg, maxval) {
var charId = personnage.charId;
var token = personnage.token;
if (msg !== undefined) {
sendChar(charId, msg);
}
evt.attributes = evt.attributes || [];
var agrandir = (attribute == 'agrandissement' && token);
var formeArbre = (attribute == 'formeDArbre' && token);
// check if the token is linked to the character. If not, use token name
// in attribute name (token ids don't persist over API reload)
if (token) {
var link = token.get('bar1_link');
if (link === "") attribute += "_" + token.get('name');
}
var attr = findObjs({
_type: 'attribute',
_characterid: charId,
name: attribute
});
if (attr.length === 0) {
if (maxval === undefined) maxval = '';
attr = createObj('attribute', {
characterid: charId,
name: attribute,
current: value,
max: maxval
});
evt.attributes.push({
attribute: attr,
current: null
});
if (agrandir) {
var width = token.get('width');
var height = token.get('height');
affectToken(token, 'width', width, evt);
affectToken(token, 'height', height, evt);
width += width / 2;
height += height / 2;
token.set('width', width);
token.set('height', height);
} else if (formeArbre) {
//On copie les PVs pour pouvoir les restaurer à la fin de l'effet
setTokenAttr(personnage, 'anciensPV', token.get('bar1_value'), evt, undefined, token.get('bar1_max'));
//On va créer une copie de token, mais avec une image d'arbre
var tokenFields = {
_pageid: token.get('pageid'),
represents: personnage.charId,
left: token.get('left'),
top: token.get('top'),
width: token.get('width'),
height: token.get('height'),
rotation: token.get('rotation'),
layer: 'objects',
name: token.get('name'),
bar1_value: token.get('bar1_value'),
bar1_max: token.get('bar1_max'),
bar1_link: token.get('bar1_link'),
bar2_value: token.get('bar2_value'),
bar2_max: token.get('bar2_max'),
bar2_link: token.get('bar2_link'),
bar3_value: token.get('bar3_value'),
bar3_max: token.get('bar3_max'),
aura1_radius: token.get('aura1_radius'),
aura1_color: token.get('aura1_color'),
aura1_square: token.get('aura1_square'),
showplayers_aura1: token.get('showplayers_aura1'),
aura2_radius: token.get('aura2_radius'),
aura2_color: token.get('aura2_color'),
aura2_square: token.get('aura2_square'),
showplayers_aura2: token.get('showplayers_aura2'),
statusmarkers: token.get('statusmarkers'),
light_radius: token.get('light_radius'),
light_dimradius: token.get('light_dimradius'),
light_otherplayers: token.get('light_otherplayers'),
light_hassight: token.get('light_hassight'),
light_angle: token.get('light_angle'),
light_losangle: token.get('light_losangle'),
light_multiplier: token.get('light_multiplier'),
showname: token.get('showname'),
showplayers_name: token.get('showplayers_name'),
showplayers_bar1: token.get('showplayers_bar1'),
};
var tokenArbre;
var imageArbre = findObjs({
_type: 'attribute',
_characterid: personnage.charId,
name: 'tokenFormeDArbre'
});
if (imageArbre.length > 0) {
tokenFields.imgsrc = imageArbre[0].get('current');
tokenArbre = createObj('graphic', tokenFields);
}
if (tokenArbre === undefined) {
tokenFields.imgsrc = stateCOF.options.images.val.image_arbre.val;
tokenArbre = createObj('graphic', tokenFields);
}
if (tokenArbre) {
//On met l'ancien token dans le gmlayer, car si l'image vient du merketplace, il est impossible de le recréer depuis l'API
setToken(token, 'layer', 'gmlayer', evt);
setTokenAttr(personnage, 'changementDeToken', true, evt);
replaceInTurnTracker(token.id, tokenArbre.id, evt);
personnage.token = tokenArbre;
token = tokenArbre;
}
//On met maintenant les nouveaux PVs
//selon Kegron http://www.black-book-editions.fr/forums.php?topic_id=4800&tid=245841#msg245841
var niveau = ficheAttributeAsInt(personnage, 'NIVEAU', 1);
var nouveauxPVs = getValeurOfEffet(personnage, 'formeDArbre', niveau * 5);
updateCurrentBar(token, 1, nouveauxPVs, evt, nouveauxPVs);
//L'initiative change
initPerso(personnage, evt, true);
}
return attr;
}
attr = attr[0];
evt.attributes.push({
attribute: attr,
current: attr.get('current'),
max: attr.get('max')
});
attr.set('current', value);
if (maxval !== undefined) attr.set('max', maxval);
return attr;
}
//fonction avec callback, mais synchrone
function soigneToken(perso, soins, evt, callTrue, callMax, options) {
options = options || {};
var token = perso.token;
var bar1 = parseInt(token.get("bar1_value"));
var pvmax = parseInt(token.get("bar1_max"));
if (isNaN(bar1) || isNaN(pvmax)) {
error("Soins sur un token sans points de vie", token);
return;
}
var updateBar1;
if (bar1 >= pvmax) bar1 = pvmax;
else updateBar1 = true;
if (soins < 0) soins = 0;
var nonSoignable = 0;
//Update des dm suivis
var attrs = findObjs({
_type: 'attribute',
_characterid: perso.charId,
});
var regSuivis = '^DMSuivis([^_]+)';
var link = token.get('bar1_link');
if (link === '') regSuivis += "_" + token.get('name') + '$';
else regSuivis += '$';
regSuivis = new RegExp(regSuivis);
var soinsSuivis = soins;
var soinsImpossible = new Set(options.saufDMType);
attrs.forEach(function(a) {
if (soinsSuivis === 0) return;
var an = a.get('name');
an = an.match(regSuivis);
if (an && an.length > 0) {
var ds = parseInt(a.get('current'));
if (ds > 0) {
if (an[0].length < 2) {
error("Match non trouvé pour les soins", an);
return;
}
if (soinsImpossible.has(an[1])) {
nonSoignable += ds;
} else {
if (ds > soinsSuivis) {
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: a,
current: ds
});
ds -= soinsSuivis;
a.set('current', ds);
soinsSuivis = 0;
} else {
soinsSuivis -= ds;
ds = 0;
}
}
} else ds = 0;
if (ds === 0) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(a);
a.remove();
}
}
});
pvmax -= nonSoignable;
if (bar1 === 0) {
if (attributeAsBool(perso, 'etatExsangue')) {
removeTokenAttr(perso, 'etatExsangue', evt, "retrouve des couleurs");
}
}
if (charAttributeAsBool(perso, 'vieArtificielle')) {
soins = Math.floor(soins / 2);
}
bar1 += soins;
var soinsEffectifs = soins;
if (bar1 > pvmax) {
if (attributeAsBool(perso, 'formeDArbre')) {
var apv = tokenAttribute(perso, 'anciensPV');
if (apv.length > 0) {
apv = apv[0];
var anciensPV = parseInt(apv.get('current'));
var anciensMax = parseInt(apv.get('max'));
if (!(isNaN(anciensPV) || isNaN(anciensMax)) &&
anciensPV < anciensMax) {
var soinsTransferes = bar1 - pvmax;
if (anciensMax - anciensPV < soinsTransferes)
soinsTransferes = anciensMax - anciensPV;
anciensPV += soinsTransferes;
bar1 -= soinsTransferes;
setTokenAttr(perso, 'anciensPV', anciensPV, evt, undefined, anciensMax);
}
}
}
// On cherche si il y a des DM temporaires à soigner
if (bar1 > pvmax) {
var hasMana = (ficheAttributeAsInt(perso, 'PM', 0) > 0);
var dmgTemp;
if (hasMana) dmgTemp = attributeAsInt(perso, 'DMTEMP', 0);
else {
dmgTemp = parseInt(token.get('bar2_value'));
if (isNaN(dmgTemp)) dmgTemp = 0;
}
if (dmgTemp > 0) {
var newDmgTemp = dmgTemp - bar1 + pvmax;
if (newDmgTemp < 0) {
newDmgTemp = 0;
bar1 -= dmgTemp;
} else bar1 = pvmax;
if (hasMana) setTokenAttr(perso, 'DMTEMP', newDmgTemp, evt);
else updateCurrentBar(token, 2, newDmgTemp, evt);
}
soinsEffectifs -= (bar1 - pvmax);
bar1 = pvmax;
}
}
if (updateBar1) updateCurrentBar(token, 1, bar1, evt);
if (soinsEffectifs > 0) {
if (callTrue) callTrue(soinsEffectifs);
} else {
if (callMax) callMax();
}
}
function setState(personnage, etat, value, evt) {
var token = personnage.token;
var charId = personnage.charId;
var aff =
affectToken(token, 'statusmarkers', token.get('statusmarkers'), evt);
if (value && etatRendInactif(etat) && isActive(personnage)) {
if (etat != 'surpris' || !surveillance(personnage))
removeFromTurnTracker(token.id, evt);
}
token.set(cof_states[etat], value);
if (!value) { //On enlève le save si il y en a un
removeTokenAttr(personnage, etat + 'Save', evt);
}
var pageId = token.get('pageid');
if (etat == 'aveugle') {
// We also change vision of the token
if (aff.prev.light_losangle === undefined)
aff.prev.light_losangle = token.get('light_losangle');
if (value) token.set('light_losangle', 0);
else token.set('light_losangle', 360);
} else if (value && etat == 'mort') {
//On libère les personnages enveloppés, si il y en a.
var attrEnveloppe = tokenAttribute(personnage, 'enveloppe');
attrEnveloppe.forEach(function(a) {
var cible = tokenOfIdName(a.get('current'), pageId);
if (cible) {
evt.deletedAttributes = evt.deletedAttributes || [];
var attrCible = tokenAttribute(cible, 'enveloppePar');
attrCible.forEach(function(a) {
var cube = tokenOfIdName(a.get('current', pageId));
if (cube.token.id == personnage.id) {
sendChar(cible.charId, 'se libère de ' + cube.tokName);
toFront(cible.token);
evt.deletedAttributes.push(a);
a.remove();
}
});
}
evt.deletedAttributes.push(a);
a.remove();
});
//On libère les personnages agrippés, si il y en a.
var attrAgrippe = tokenAttribute(personnage, 'agrippe');
attrAgrippe.forEach(function(a) {
var cible = tokenOfIdName(a.get('current'), pageId);
if (cible) {
evt.deletedAttributes = evt.deletedAttributes || [];
var attrCible = tokenAttribute(cible, 'estAgrippePar');
attrCible.forEach(function(a) {
var agrippant = tokenOfIdName(a.get('current', pageId));
if (agrippant.token.id == personnage.id) {
sendChar(cible.charId, 'se libère de ' + agrippant.tokName);
toFront(cible.token);
if (a.get('max')) setState(cible, 'immobilise', false, evt);
evt.deletedAttributes.push(a);
a.remove();
}
});
}
evt.deletedAttributes.push(a);
a.remove();
});
if (charAttributeAsBool(personnage, 'armeeConjuree')) {
removeFromTurnTracker(personnage.token.id, evt);
personnage.token.remove();
sendChar(personnage.charId, 'disparaît');
var armeeChar = getObj('character', personnage.charId);
if (armeeChar) {
evt.deletedCharacters = evt.deletedCharacters || [];
evt.deletedCharacters.push({
id: personnage.charId,
name: armeeChar.get('name'),
avatar: armeeChar.get('avatar'),
attributes: findObjs({
_type: 'attributes',
_characterid: personnage.charId
}),
abilities: findObjs({
_type: 'ability',
_characterid: personnage.charId
})
});
armeeChar.remove();
}
} else if (!estNonVivant(personnage)) {
//Cherche si certains peuvent siphoner l'âme
var allToks =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
allToks.forEach(function(tok) {
if (tok.id == token.id) return;
var ci = tok.get('represents');
if (ci === '') return;
var p = {
token: tok,
charId: ci
};
if (getState(p, 'mort')) return;
if (distanceCombat(token, tok, pageId) > 20) return;
if (charIdAttributeAsBool(ci, 'siphonDesAmes')) {
var bonus = charAttributeAsInt(p, 'siphonDesAmes', 0);
var soin = rollDePlus(6, {
bonus: bonus
});
soigneToken(p, soin.val, evt,
function(s) {
var siphMsg = "siphone l'âme de " + token.get('name') +
". Il récupère ";
if (s == soin.val) siphMsg += soin.roll + " pv.";
else siphMsg += s + " pv (jet " + soin.roll + ").";
sendChar(ci, siphMsg);
},
function() {
sendChar(ci, "est déjà au maximum de point de vie. Il laisse échapper l'âme de " + token.get('name'));
});
}
});
}
}
if (token.get('bar1_link') !== "") {
if (charId === '') {
error("token with a linked bar1 but representing no character", token);
return;
}
if (etat == 'affaibli') { //special case due to new character sheet
var attr =
findObjs({
_type: 'attribute',
_characterid: charId,
name: 'ETATDE'
}, {
caseInsensitive: true
});
if (value) {
if (attr.length === 0) {
attr =
createObj('attribute', {
characterid: charId,
name: 'ETATDE',
current: 12
});
if (evt.attributes)
evt.attributes.push({
attribute: attr,
current: null
});
else evt.attributes = [{
attribute: attr,
current: null
}];
} else {
attr = attr[0];
if (parseInt(attr.get('current')) != 12) {
if (evt.attributes)
evt.attributes.push({
attribute: attr,
current: 20
});
else evt.attributes = [{
attribute: attr,
current: 20
}];
attr.set('current', 12);
}
}
} else {
if (attr.length > 0) {
attr = attr[0];
if (parseInt(attr.get('current')) != 20) {
if (evt.attributes)
evt.attributes.push({
attribute: attr,
current: 12
});
else evt.attributes = [{
attribute: attr,
current: 12
}];
attr.set('current', 20);
}
}
}
} else {
var attrEtat =
findObjs({
_type: 'attribute',
_characterid: charId,
name: etat
});
if (value) {
if (attrEtat.length === 0) {
attrEtat =
createObj('attribute', {
characterid: charId,
name: etat,
current: value
});
if (evt.attributes)
evt.attributes.push({
attribute: attrEtat,
current: null
});
else evt.attributes = [{
attribute: attrEtat,
current: null
}];
}
} else {
if (attrEtat.length > 0) {
attrEtat[0].remove();
if (evt.deletedAttributes) {
evt.deletedAttributes.push(attrEtat[0]);
} else {
evt.deletedAttributes = [attrEtat[0]];
}
}
}
}
}
if (!value && etatRendInactif(etat) && isActive(personnage) ||
etat == 'aveugle') updateInit(token, evt);
}
function logEvents() {
var l = eventHistory.length;
log("Historique de taille " + l);
eventHistory.forEach(function(evt, i) {
log("evt " + i);
log(evt);
});
}
function addEvent(evt) {
evt.id = stateCOF.eventId++;
eventHistory.push(evt);
if (eventHistory.length > HISTORY_SIZE) {
eventHistory.shift();
}
}
function findEvent(id) {
return eventHistory.find(function(evt) {
return (evt.id == id);
});
}
function lastEvent() {
var l = eventHistory.length;
if (l === 0) return undefined;
return eventHistory[l - 1];
}
//Si evt n'est pas défini, annule le dernier evt
function undoEvent(evt) {
if (evt === undefined) {
if (eventHistory.length === 0) {
sendChat('COF', "/w GM Historique d'évènements vide");
return;
}
evt = eventHistory.pop();
} else {
eventHistory = eventHistory.filter(function(e) {
return (e.id != evt.id);
});
}
if (evt === undefined) {
error("No event to undo", eventHistory);
return;
}
sendChat("COF", "/w GM undo " + evt.type);
if (evt.affectes) undoTokenEffect(evt);
if (evt.attributes) {
// some attributes where modified too
evt.attributes.forEach(function(attr) {
if (attr.current === null) attr.attribute.remove();
else {
attr.attribute.set('current', attr.current);
if (attr.max) attr.attribute.set('max', attr.max);
}
});
}
if (evt.deletedCharacters) {
evt.deletedCharacters.forEach(function(character) {
var nameDel = character.name;
log("Restoring character " + nameDel);
var newCharacter =
createObj('character', {
name: nameDel,
avatar: character.avatar
});
var charId = newCharacter.id;
var tokens = findObjs({
_type: 'graphic',
represents: character.id
});
tokens.forEach(function(tok) {
tok.set('represents', charId);
});
eventHistory.forEach(function(evt) {
if (evt.characters) {
evt.characters = evt.characters.map(function(oldCharac) {
if (oldCharac.id == character.id) return newCharacter;
return oldCharac;
});
}
if (evt.deletedAttributes) {
evt.deletedAttributes.forEach(function(attr) {
if (attr.id == character.id) attr.newCharId = charId;
});
}
});
//Maintenant on remet les attributs
if (character.attributes) {
character.attributes.forEach(function(attr) {
var oldId = attr.id;
var newAttr = createObj('attribute', {
characterid: charId,
name: attr.get('name'),
current: attr.get('current'),
max: attr.get('max')
});
eventHistory.forEach(function(evt) {
if (evt.attributes) {
evt.attributes.forEach(function(attr) {
if (attr.attribute.id == oldId) attr.attribute = newAttr;
});
}
});
tokens.forEach(function(tok) {
if (tok.get('bar1_link') == oldId)
tok.set('bar1_link', newAttr.id);
});
});
}
if (character.abilities) {
character.abilities.forEach(function(ab) {
var newAb = createObj('ability', {
characterid: charId,
name: ab.get('name'),
action: ab.get('action'),
istokenaction: ab.get('istokenaction')
});
});
}
});
}
// deletedAttributes have a quadratic cost in the size of the history
if (evt.deletedAttributes) {
evt.deletedAttributes.forEach(function(attr) {
var oldId = attr.id;
var nameDel = attr.get('name');
log("Restoring attribute " + nameDel);
var newAttr =
createObj('attribute', {
characterid: attr.newCharId || attr.get('characterid'),
name: nameDel,
current: attr.get('current'),
max: attr.get('max')
});
eventHistory.forEach(function(evt) {
if (evt.attributes !== undefined) {
evt.attributes.forEach(function(attr) {
if (attr.attribute.id == oldId) attr.attribute = newAttr;
});
}
});
});
}
if (evt.characters) {
evt.characters.forEach(function(character) {
var charId = character.id;
findObjs({
_type: 'attribute',
_characterid: charId
}).forEach(function(attr) {
attr.remove();
});
findObjs({
_type: 'ability',
_characterid: charId
}).forEach(function(ab) {
ab.remove();
});
character.remove();
});
}
if (evt.tokens) {
evt.tokens.forEach(function(token) {
token.remove();
});
}
if (_.has(evt, 'combat')) stateCOF.combat = evt.combat;
if (_.has(evt, 'combat_pageid')) stateCOF.combat_pageid = evt.combat_pageid;
if (_.has(evt, 'tour')) stateCOF.tour = evt.tour;
if (_.has(evt, 'init')) stateCOF.init = evt.init;
if (_.has(evt, 'activeTokenId')) stateCOF.activeTokenId = evt.activeTokenId;
if (_.has(evt, 'updateNextInitSet'))
updateNextInitSet = evt.updateNextInitSet;
if (_.has(evt, 'turnorder'))
Campaign().set('turnorder', evt.turnorder);
if (_.has(evt, 'initiativepage'))
Campaign().set('initiativepage', evt.initiativepage);
}
function undoTokenEffect(evt) {
var HTdeclared;
try {
HTdeclared = HealthColors;
} catch (e) {
if (e.name != "ReferenceError") throw (e);
}
_.each(evt.affectes, function(aff) {
var prev = aff.prev;
var tok = aff.affecte;
if (prev === undefined || tok === undefined) {
error("Pas d'état précédant", aff);
return;
}
var prevTok;
if (HTdeclared) prevTok = JSON.parse(JSON.stringify(tok));
_.each(prev, function(val, key) {
tok.set(key, val);
});
if (HTdeclared) HealthColors.Update(tok, prevTok);
sendChat("COF", "État de " + tok.get("name") + " restauré.");
});
}
function caracOfMod(m) {
switch (m) {
case 'FOR':
return 'FORCE';
case 'DEX':
return 'DEXTERITE';
case 'CON':
return 'CONSTITUTION';
case 'INT':
return 'INTELLIGENCE';
case 'SAG':
return 'SAGESSE';
case 'CHA':
return 'CHARISME';
default:
return;
}
}
//Retourne le mod de la caractéristque entière.
//si carac n'est pas une carac, retourne 0
function modCarac(perso, carac) {
if (perso.charId === undefined) perso = {
charId: perso
};
var res = Math.floor((ficheAttributeAsInt(perso, carac, 10) - 10) / 2);
if (carac == 'FORCE' && attributeAsBool(perso, 'mutationMusclesHypertrophies')) res += 2;
else if (carac == 'DEXTERITE' && attributeAsBool(perso, 'mutationSilhouetteFiliforme')) res += 4;
return res;
}
//Renvoie le token et le charId. Si l'id ne correspond à rien, cherche si
//on trouve un nom de token, sur la page passée en argument (ou sinon
//sur la page active de la campagne)
function tokenOfId(id, name, pageId) {
var token = getObj('graphic', id);
if (token === undefined) {
if (name === undefined) return undefined;
if (pageId === undefined) {
pageId = Campaign().get('playerpageid');
}
var tokens = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
name: name
});
if (tokens.length === 0) return undefined;
if (tokens.length > 1) {
error("Ambigüité sur le choix d'un token : il y a " +
tokens.length + " tokens nommés" + name, tokens);
}
token = tokens[0];
}
var charId = token.get('represents');
if (charId === '') {
error("le token sélectionné ne représente pas de personnage", token);
return undefined;
}
return {
token: token,
charId: charId
};
}
function tokenOfIdName(idn, pageId) {
var pos = idn.indexOf(' ');
if (pos < 1 || pos >= idn.length) {
error("IdName mal formé", idn);
return;
}
var name = idn.substring(pos + 1);
var perso = tokenOfId(idn.substring(0, pos), name, pageId);
perso.tokName = perso.token.get('name');
if (perso.tokName == name) return perso;
log("En cherchant le token " + idn + ", on trouve " + perso.tokName);
log(perso);
return perso;
}
function boutonSimple(action, style, texte) {
action = action.replace(/%/g, '%').replace(/\)/g, ')').replace(/\?/g, '?').replace(/@/g, '@').replace(/\[/g, '[').replace(/]/g, ']').replace(/"/g, '"').replace(/{/g, '{').replace(/}/g, '}').replace(/\|/g, '|');
action = action.replace(/\'/g, '''); // escape quotes
return '<a href="' + action + '"' + style + '>' + texte + '</a>';
}
// on, remplace tous les selected par @{character name|attr}
function escapeRegExp(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}
//Remplace une macro ou ability par sa définition (récursivement)
function replaceAction(action, perso, macros, abilities) {
var remplacement = false;
if (action.indexOf('#') >= 0) {
macros = macros || findObjs({
_type: 'macro'
});
macros.forEach(function(m, i) {
var mName = '#' + m.get('name');
if (action.indexOf(mName) >= 0) {
mName = new RegExp(mName + "\\b", "g");
action = action.replace(mName, m.get('action'));
if (!remplacement)
macros = macros.filter(function(m, k) {
return (k != i);
}); //Pour éviter la récursion
remplacement = true;
}
});
}
if (action.indexOf('%') >= 0) {
abilities = abilities || findObjs({
_type: 'ability',
_characterid: perso.charId
});
abilities.forEach(function(a, i) {
var aName = a.get('name');
var daName = '%' + aName;
if (action.indexOf(daName) >= 0) {
action = action.replace(daName, a.get('action'));
if (!remplacement) abilities = abilities.splice(i); //Pour éviter la récursion
remplacement = true;
}
daName = '%{selected|' + aName + '}';
if (action.indexOf(daName) >= 0) {
action = action.replace(daName, a.get('action'));
if (!remplacement)
abilities = abilities.filter(function(m, k) {
return (k != i);
}); //Pour éviter la récursion
remplacement = true;
}
});
}
if (remplacement) return replaceAction(action, perso, macros, abilities);
return action;
}
//ressource est optionnel, et si présent doit être un attribut
function bouton(action, text, perso, ressource, overlay, style) {
if (action === undefined || action.trim().length === 0) return text;
else action = action.trim();
//Expansion des macros et abilities
action = replaceAction(action, perso);
var tid = perso.token.id;
perso.tokName = perso.tokName || perso.token.get('name');
if (perso.name === undefined) {
var character = getObj('character', perso.charId);
if (character) perso.name = character.get('name');
else perso.name = perso.tokName;
}
//Cas de plusieurs actions après expansion
var actions = action.split('\n');
actions = actions.map(function(act) {
act = act.trim();
if (act.startsWith("/as ")) {
act = "!cof-as" + act.substring(3);
}
if (act.charAt(0) == '!') {
if (act.startsWith('!cof')) {
if (ressource) act += " --decrAttribute " + ressource.id;
} else if (!act.startsWith('!
')) return act; //On ne touche pas aux commandes des autres scripts
} else {
if (ressource) {
act = "!cof-utilise-consommable " + tid + " " + ressource.id + " --message " + act;
} else {
act = "!cof-lancer-sort 0 " + act;
}
}
if (act.indexOf('@{selected') !== -1) {
// cas spécial pour @{selected|token_id} où l'on remplace toutes les occurences par token.id
act = act.replace(new RegExp(escapeRegExp('@{selected|token_id}'), 'g'), tid);
act = act.replace(new RegExp(escapeRegExp('@{selected|token_name}'), 'g'), perso.tokName);
var tmp = act.split('@{selected');
tmp.forEach(function(elem) {
if (elem.startsWith('|')) {
// attribut demandé
var attribute_name = elem.substring(0, elem.indexOf("}")).substr(1);
var attrs = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: attribute_name
});
var replacement;
if (attrs.length === 0)
replacement = '@{' + perso.name + '|' + attribute_name + '}';
else
replacement = attrs[0].get('current');
act = act.replace(new RegExp(escapeRegExp('@{selected|' + attribute_name + '}'), 'g'), replacement);
}
});
}
if (act.startsWith('!cof-lancer-sort') && act.indexOf('--lanceur') == -1) {
act = "!cof-lancer-sort --lanceur " + tid + act.substr(16);
}
if (act.indexOf('@{target|') == -1 &&
act.indexOf('cof-lancer-sort') == -1 &&
act.indexOf('cof-surprise') == -1 &&
act.indexOf('cof-attack') == -1 &&
act.indexOf('cof-soin') == -1 &&
act.indexOf('cof-as ') == -1 &&
act.indexOf('--equipe') == -1 &&
act.indexOf('--target ' + tid) == -1) {
//Si on n'a pas de cible, on fait comme si le token était sélectionné.
var add_token = " --target " + tid;
if (act.indexOf(' --allie') >= 0) {
if (act.indexOf('--lanceur') == -1)
add_token = " --lanceur " + tid;
else add_token = ""; //La cible sont les alliés de --lanceur.
}
if (act.indexOf(' --message ') != -1) act = act.replace(' --message ', add_token + ' --message ');
else act += add_token;
}
return act;
});
var pictoStyle = getPictoStyleFromCommand(action, perso);
if (actions.length == 1) action = actions[0];
else
action = "!cof-multi-command " + actions.join(' --cof-multi-command ');
text = pictoStyle.picto + text;
var buttonStyle = '';
if (style) buttonStyle = ' style="' + style + '"';
else if (pictoStyle.style)
buttonStyle = ' style="' + pictoStyle.style + '"';
if (overlay) overlay = ' title="' + overlay + '"';
else overlay = '';
return boutonSimple(action, buttonStyle + overlay, text);
}
function improve_image(image_url) {
if (image_url) {
image_url = image_url.replace('/med.png', '/thumb.png');
image_url = image_url.substring(0, image_url.indexOf('?'));
return image_url;
}
}
//Fonction séparée pour pouvoir envoyer un frame à plusieurs joueurs
// playerId peut être undefined (en particulier pour envoye au mj)
function addFramedHeader(display, playerId, chuchote) {
var perso1 = display.perso1;
var perso2 = display.perso2;
var action = display.action;
var playerBGColor = '#333';
var playerTXColor = '#FFF';
var displayname;
var player = getObj('player', playerId);
if (player !== undefined) {
playerBGColor = player.get("color");
playerTXColor = (getBrightness(playerBGColor) < 50) ? "#FFF" : "#000";
displayname = player.get('displayname');
}
var res = '/direct ';
if (chuchote) {
var who;
if (chuchote !== true) who = chuchote;
else who = displayname;
if (who) res = '/w "' + who + '" ';
else chuchote = false;
}
var name1, name2 = '';
var avatar1, avatar2;
if (perso2) {
var img2 = improve_image(perso2.token.get('imgsrc'));
if (stateCOF.options.affichage.val.avatar_dans_cadres.val) {
var character2 = getObj('character', perso2.charId);
if (character2) img2 = improve_image(character2.get('avatar')) || img2;
}
if (img2) {
avatar2 = '<img src="' + img2 + '" style="width: 50%; display: block; max-width: 100%; height: auto; border-radius: 6px; margin: 0 auto;">';
name2 = perso2.tokName;
if (name2 === undefined) name2 = perso2.token.get('name');
name2 = '<b>' + name2 + '</b>';
}
}
if (perso1) {
var img1 = improve_image(perso1.token.get('imgsrc'));
if (stateCOF.options.affichage.val.avatar_dans_cadres.val) {
var character1 = getObj('character', perso1.charId);
if (character1) img1 = improve_image(character1.get('avatar')) || img1;
}
if (img1) {
avatar1 = '<img src="' + img1 + '" style="width: ' + (avatar2 ? 50 : 100) + '%; display: block; max-width: 100%; height: auto; border-radius: 6px; margin: 0 auto;">';
if (perso1.tokName) name1 = perso1.tokName;
else name1 = perso1.token.get('name');
name1 = '<b>' + name1 + '</b>';
}
}
res +=
'<div class="all_content" style="-webkit-box-shadow: 2px 2px 5px 0px rgba(0,0,0,0.75); -moz-box-shadow: 2px 2px 5px 0px rgba(0,0,0,0.75); box-shadow: 2px 2px 5px 0px rgba(0,0,0,0.75); border: 1px solid #000; border-radius: 6px; -moz-border-radius: 6px; -webkit-border-radius: 6px; overflow: hidden; position: relative;">';
if (avatar1) {
res +=
'<div class="line_header" style="overflow:auto; text-align: center; vertical-align: middle; padding: 5px 5px; border-bottom: 1px solid #000; color: ' + playerTXColor + '; background-color: ' + playerBGColor + ';" title=""> ' +
'<table>';
if (avatar2) {
res +=
'<tr style="text-align: center">' +
'<td style="width: 44%; vertical-align: middle;">' + name1 + '</td>' +
'<td style="width: 12%;height: 28px;line-height: 30px;border: 2px solid #900;border-radius: 100%;position: absolute;margin-top: 25px;font-weight: bold;background-color: #EEE;color: #900;">' + 'VS' + '</td>' +
'<td style="width: 44%; vertical-align: middle;">' + name2 + '</td>' +
'</tr>' +
'<tr style="text-align: center">' +
'<td style="width: 42%; vertical-align: middle;">' + avatar1 + '</td>' +
'<td style="width: 16%; vertical-align: middle;"> </td>' +
'<td style="width: 42%; vertical-align: middle;">' + avatar2 + '</td>' +
'</tr>';
} else {
var bar1_info = '',
bar2_info = '',
bar3_info = '';
if (chuchote && peutController(playerId, perso1)) {
// on chuchote donc on peut afficher les informations concernant les barres du Token
if (perso1.token.get('bar1_link').length > 0) {
var bar1 = findObjs({
_type: 'attribute',
_id: perso1.token.get('bar1_link')
});
if (bar1[0] !== undefined) bar1_info = '<b>' + bar1[0].get('name') + '</b> : ' + bar1[0].get('current') + ' / ' + bar1[0].get('max') + '';
}
if (perso1.token.get('bar2_link').length > 0) {
var bar2 = findObjs({
_type: 'attribute',
_id: perso1.token.get('bar2_link')
});
if (bar2[0] !== undefined) bar2_info = '<b>' + bar2[0].get('name') + '</b> : ' + bar2[0].get('current') + ' / ' + bar2[0].get('max') + '';
}
if (perso1.token.get('bar3_link').length > 0) {
var bar3 = findObjs({
_type: 'attribute',
_id: perso1.token.get('bar3_link')
});
if (bar3[0] !== undefined) bar3_info = '<b>' + bar3[0].get('name') + '</b> : ' + bar3[0].get('current') + ' / ' + bar3[0].get('max') + '';
}
}
res +=
'<tr style="text-align: left">' +
'<td style="width:25%; vertical-align: middle;">' + avatar1 +
'</td>' +
'<td style="width:75%; vertical-align: middle; position: relative;">' +
'<div>' + name1 + '</div>' +
'<div style="position: absolute;top: -6px;right: -5px;border: 1px solid #000;background-color: #333;">' +
'<div style="text-align: right; margin: 0 5px; color: #7cc489">' + bar1_info + '</div>' +
'<div style="text-align: right; margin: 0 5px; color: #7c9bc4">' + bar2_info + '</div>' +
'<div style="text-align: right; margin: 0 5px; color: #b21d1d">' + bar3_info + '</div>' +
'</div>' +
'</td>' +
'</tr>';
}
res +=
'</table>' +
'</div>'; // line_header
}
res +=
'<div class="line_title" style="font-size: 85%; text-align: left; vertical-align: middle; padding: 5px 5px; border-bottom: 1px solid #000; color: #a94442; background-color: #f2dede;" title=""> ' +
action +
'</div>'; // line_title
res += '<div class="line_content">';
display.header = res;
}
//Si options.chuchote est vrai, la frame est chuchotée au joueur qui fait l'action
//Si options.chuchote est un nom, on chuchote la frame à ce nom
//Pour retarder la décision sur la cible de chuchotement, utiliser options.retarder
function startFramedDisplay(playerId, action, perso, options) {
options = options || {};
var display = {
output: '',
isOdd: true,
isfirst: true,
perso1: perso,
perso2: options.perso2,
action: action
};
if (options.retarde === undefined)
addFramedHeader(display, playerId, options.chuchote);
return display;
}
function addLineToFramedDisplay(display, line, size, newLine) {
size = size || 100;
newLine = (newLine !== undefined) ? newLine : true;
var background_color, border = '',
separator = '';
if (!newLine) display.isOdd = !display.isOdd;
if (display.isOdd) {
background_color = "#FFF";
display.isOdd = false;
} else {
background_color = "#f3f3f3";
display.isOdd = true;
}
if (size < 100) background_color = "#fcf8e3";
if (!display.isfirst) {
if (newLine) border = "border-top: 1px solid #333;";
} else display.isfirst = false;
var formatedLine = '<div style="padding: 0 5px 0; background-color: ' + background_color + '; color: #000;' + border + '">';
if (!newLine) separator = "border-top: 1px solid #ddd;";
formatedLine += '<div style="padding: 4px 0; font-size: ' + size + '%;' + separator + '">' + line + '</div>';
formatedLine += '</div>';
display.output += formatedLine;
}
function startTableInFramedDisplay(display) {
display.output += "<table>";
display.endColumn = true;
}
function endTableInFramedDisplay(display) {
if (!display.endColumn) display.output += "</tr>";
display.output += "</table>";
}
//newLine indique qu'on commence une nouvelle rangée
function addCellInFramedDisplay(display, cell, size, newLine) {
size = size || 100;
if (display.endColumn) {
display.output += '<tr>';
display.endColumn = false;
} else if (newLine) display.output += '</tr><tr>';
display.output += '<td style="background-color: #FFF; font-size: ' + size + '%; height: ' + size + '%">' + cell + '</td>';
}
function endFramedDisplay(display) {
if (display.header === undefined) {
error("Pas de titre pour le cadre", display);
return;
}
var res = display.header + display.output;
res += '</div>'; // line_content
res += '</div>'; // all_content
return res;
}
function tokenAttribute(personnage, name) {
var token = personnage.token;
if (token) {
var link = token.get('bar1_link');
if (link === "") name += "_" + token.get('name');
}
return findObjs({
_type: 'attribute',
_characterid: personnage.charId,
name: name
});
}
function charAttribute(charId, name, option) {
return findObjs({
_type: 'attribute',
_characterid: charId,
name: name
}, option);
}
function attrAsInt(attr, def) {
if (attr.length === 0) return def;
attr = parseInt(attr[0].get('current'));
if (isNaN(attr)) return def;
return attr;
}
function attrAsBool(attr) {
if (attr.length === 0) return false;
attr = attr[0].get('current');
if (attr == '0') return false;
if (attr) return true;
return false;
}
// Caution : does not work with repeating attributes!!!!
function ficheAttribute(personnage, name, def) {
var attr = charAttribute(personnage.charId, name, {
caseInsensitive: true
});
if (attr.length === 0) return def;
return attr[0].get('current');
}
function ficheAttributeAsInt(personnage, name, def) {
var attr = charAttribute(personnage.charId, name, {
caseInsensitive: true
});
if (attr === undefined) return def;
return attrAsInt(attr, def);
}
function ficheAttributeAsBool(personnage, name) {
var attr = charAttribute(personnage.charId, name, {
caseInsensitive: true
});
return attrAsBool(attr);
}
// Caution not to use token when the attribute should not be token dependant
function attributeAsInt(personnage, name, def) {
var attr = tokenAttribute(personnage, name);
return attrAsInt(attr, def);
}
function attributeAsBool(personnage, name) {
var attr = tokenAttribute(personnage, name);
return attrAsBool(attr);
}
function charAttributeAsInt(perso, name, def) {
var attr = charAttribute(perso.charId, name);
return attrAsInt(attr, def);
}
function charAttributeAsBool(perso, name) {
var attr = charAttribute(perso.charId, name);
return attrAsBool(attr);
}
function charIdAttributeAsBool(charId, name) {
var attr = charAttribute(charId, name);
return attrAsBool(attr);
}
// Test de caractéristique
// options : bonusAttrs, bonus, roll
// Après le test, lance callback(testRes)
// testRes.texte est l'affichage du jet de dé
// testRes.reussite indique si le jet est réussi
// testRes.echecCritique, testRes.critique pour le type
function testCaracteristique(personnage, carac, seuil, options, evt, callback) { //asynchrone
options = options || {};
var token = personnage.token;
var bonusCarac = bonusTestCarac(carac, personnage, evt);
if (options.bonusAttrs) {
options.bonusAttrs.forEach(function(attr) {
bonusCarac += charAttributeAsInt(personnage, attr, 0);
});
}
if (options.bonus) bonusCarac += options.bonus;
var testRes = {};
if (carac == 'SAG' || carac == 'INT' || carac == 'CHA') {
if (charAttributeAsBool(personnage, 'sansEsprit')) {
testRes.reussite = true;
testRes.texte = "(sans esprit : réussite automatique)";
callback(testRes);
return;
}
}
var carSup = nbreDeTestCarac(carac, personnage);
var de = computeDice(personnage, {
nbDe: carSup,
carac: carac
});
var rollExpr = "[[" + de + "cs20cf1]]";
var name = personnage.name || getObj('character', personnage.charId).get('name');
sendChat("", rollExpr, function(res) {
var roll = options.roll || res[0].inlinerolls[0];
testRes.roll = roll;
var d20roll = roll.results.total;
var bonusText = (bonusCarac > 0) ? "+" + bonusCarac : (bonusCarac === 0) ? "" : bonusCarac;
testRes.texte = buildinline(roll) + bonusText;
if (d20roll == 20) {
testRes.reussite = true;
testRes.critique = true;
} else if (d20roll == 1) {
testRes.reussite = false;
testRes.echecCritique = true;
diminueMalediction(personnage, evt);
} else if (d20roll + bonusCarac >= seuil) {
testRes.reussite = true;
} else {
diminueMalediction(personnage, evt);
testRes.reussite = false;
}
callback(testRes);
});
}
function pointsDeChance(perso) {
if (!estPJ(perso)) return 0;
var optionPC = ficheAttributeAsInt(perso, 'option_pc', 1);
if (optionPC === 0) return 0;
return ficheAttributeAsInt(perso, 'pc', 3);
}
function jetPerso(perso, caracteristique, difficulte, titre, playerId, options) {
options = options || {};
var evt = options.evt || {
type: "Jet de " + caracteristique
};
var optionsDisplay = {};
if (options.secret) {
if (playerIsGM(playerId)) optionsDisplay.chuchote = true;
else {
var character = getObj('character', perso.charId);
if (character) {
optionsDisplay.chuchote = '"' + character.get('name') + '"';
var controledByGM = false;
var charControlledby = character.get('controlledby');
charControlledby.split(",").forEach(function(controlledby) {
if (playerIsGM(controlledby)) controledByGM = true;
});
if (!controledByGM) optionsDisplay.retarde = true;
} else optionsDisplay.retarde = true;
}
}
var display = startFramedDisplay(playerId, titre, perso, optionsDisplay);
if (difficulte === undefined) {
jetCaracteristique(perso, caracteristique, options, evt,
function(rt, explications) {
explications.forEach(function(m) {
addLineToFramedDisplay(display, m);
});
addLineToFramedDisplay(display, "<b>Résultat :</b> " + rt.texte);
addStatistics(playerId, ["Jet de carac", caracteristique], rt.roll);
// Maintenant, on diminue la malédiction si le test est un échec
var attrMalediction = tokenAttribute(perso, 'malediction');
if (attrMalediction.length > 0) {
if (rt.echecCritique)
diminueMalediction(perso, evt, attrMalediction);
else if (!rt.critique) {
var action = "!cof-resultat-jet " + stateCOF.eventId;
var ligne = "L'action est-elle ";
ligne += bouton(action + " reussi", "réussie", perso);
ligne += " ou " + bouton(action + " rate", "ratée", perso);
ligne += " ?";
addLineToFramedDisplay(display, ligne);
evt.personnage = perso;
evt.attenteResultat = true;
}
}
addEvent(evt);
if (optionsDisplay.retarde) {
addFramedHeader(display, playerId, true);
sendChat('', endFramedDisplay(display));
addFramedHeader(display, undefined, 'gm');
sendChat('', endFramedDisplay(display));
} else sendChat('', endFramedDisplay(display));
});
} else {
if (options.chance) options.bonus = options.chance * 10;
testCaracteristique(perso, caracteristique, difficulte, options, evt,
function(tr) {
addLineToFramedDisplay(display, "<b>Résultat :</b> " + tr.texte);
addEvent(evt);
if (tr.reussite) {
addLineToFramedDisplay(display, "C'est réussi.");
} else {
//TODO : ajouter le pacte sanglant, la prouesse et le tour de force
var msgRate = "C'est raté.";
evt.personnage = perso;
evt.action = {
caracteristique: caracteristique,
difficulte: difficulte,
titre: titre,
playerId: playerId,
options: options
};
evt.type = 'jetPerso';
var pc = pointsDeChance(perso);
if (pc > 0) {
options.roll = options.roll || tr.roll;
msgRate += ' ' +
bouton("!cof-bouton-chance " + evt.id, "Chance", perso) +
" (reste " + pc + " PC)";
}
if (charAttributeAsBool(perso, 'runeDEnergie') && (caracteristique == 'FOR' || caracteristique == 'CON' || caracteristique == 'DEX')) {
msgRate += ' ' + bouton("!cof-bouton-rune-energie " + evt.id, "Rune d'énergie", perso);
}
addLineToFramedDisplay(display, msgRate);
}
if (optionsDisplay.retarde) {
addFramedHeader(display, playerId, true);
sendChat('', endFramedDisplay(display));
addFramedHeader(display, undefined, 'gm');
sendChat('', endFramedDisplay(display));
} else sendChat('', endFramedDisplay(display));
});
}
}
//Par construction, msg.content ne doit pas contenir d'option --nom,
//et commencer par !cof-jet
function boutonsCompetences(display, perso, carac, msg) {
var action = msg.content;
action = action.replace(/ --competences /, '');
action = action.replace(/ --competences/, ''); //au cas où ce serait le dernier argument
var args = action.substring(9); //on enlève !cof-jet
if (!args.startsWith(carac)) action = "!cof-jet " + carac + " " + args;
var pictoCarac = carac;
var overlay;
switch (carac) {
case 'FOR':
pictoCarac = '<span style="font-family: \'Pictos\'">S</span>';
overlay = 'Force';
break;
case 'DEX':
pictoCarac = '<span style="font-family: \'Pictos Custom\'">t</span>';
overlay = 'Dextérité';
break;
case 'CON':
pictoCarac = '<span style="font-family: \'Pictos\'">k</span>';
overlay = 'Constitution';
break;
case 'INT':
pictoCarac = '<span style="font-family: \'Pictos Custom\'">y</span>';
overlay = 'Intelligence';
break;
case 'SAG':
pictoCarac = '☯';
overlay = 'Sagesse';
break;
case 'CHA':
pictoCarac = '<span style="font-family: \'Pictos\'">w</span>';
overlay = 'Charisme';
break;
}
var cell = bouton(action, pictoCarac, perso, undefined, overlay);
addCellInFramedDisplay(display, cell, 150, true);
var comps = listeCompetences[carac];
cell = '';
var sec = false;
comps.forEach(function(comp) {
if (sec) cell += ' ';
else sec = true;
cell += bouton(action + " --nom " + comp, comp, perso, undefined, undefined, "background-color:#996600");
});
addCellInFramedDisplay(display, cell, 80, false);
}
function computeScale(pageId) {
var page = getObj("page", pageId);
var scale = page.get('scale_number');
var unit = page.get('scale_units');
if (unit == 'ft') scale *= 0.3048;
return scale;
}
//options peut avoir les champs:
// - strict1 = true si on considère que tok1 doit avoir une taille nulle
// - strict2
// - allonge
function distanceCombat(tok1, tok2, pageId, options) {
if (pageId === undefined) {
pageId = tok1.get('pageid');
}
var scale = computeScale(pageId);
var pt1 = tokenCenter(tok1);
var pt2 = tokenCenter(tok2);
var distance_pix = VecMath.length(VecMath.vec(pt1, pt2));
options = options || {};
if (!options.strict1) distance_pix -= tokenSize(tok1, PIX_PER_UNIT / 2);
if (!options.strict2) distance_pix -= tokenSize(tok2, PIX_PER_UNIT / 2);
if (options.allonge) distance_pix -= (options.allonge * PIX_PER_UNIT) / scale;
if ((!options.strict1 || !options.strict2) && distance_pix < PIX_PER_UNIT * 1.4) return 0; //cases voisines
return ((distance_pix / PIX_PER_UNIT) * scale);
}
function getPageId(playerId) {
var pageId;
if (playerIsGM(playerId)) {
var player = getObj('player', playerId);
pageId = player.get('lastpage');
}
if (pageId === undefined || pageId === "") {
var pages = Campaign().get('playerspecificpages');
if (pages && pages[playerId] !== undefined) {
return pages[playerId];
}
return Campaign().get('playerpageid');
}
return pageId;
}
// si défini, callback est appelé à chaque élément de selected
// qui n'est pas un personnage
// iter seulement sur les élément qui correspondent à des personnages
function iterSelected(selected, iter, callback) {
selected.forEach(function(sel) {
var token = getObj('graphic', sel._id);
if (token === undefined) {
if (callback !== undefined) callback();
return;
}
var charId = token.get('represents');
if (charId === undefined || charId === "") {
if (callback !== undefined) callback();
return;
}
iter({
token: token,
charId: charId
});
});
}
// callback(selected, playerId)
function getSelected(msg, callback, options) {
var playerId = getPlayerIdFromMsg(msg);
var pageId;
if (options && options.pageId) pageId = options.pageId;
else pageId = getPageId(playerId);
var args = msg.content.split(' --');
var selected = [];
var enleveAuxSelected = [];
var count = args.length - 1;
var called;
options = options || {};
var actif = options.lanceur;
var finalCall = function() {
called = true;
var seen = new Set();
var res = selected.filter(function(sel) {
if (seen.has(sel._id)) return false;
seen.add(sel._id);
var interdit = enleveAuxSelected.find(function(i) {
return (i._id == sel._id);
});
return (interdit === undefined);
});
callback(res, playerId);
};
if (args.length > 1) {
args.shift();
args.forEach(function(cmd) {
count--;
var cmdSplit = cmd.split(' ');
switch (cmdSplit[0]) {
case 'equipe':
var nomEquipe = 'Equipe' + cmd.substring(cmd.indexOf(' '));
var equipes = findObjs({
_type: 'handout',
name: nomEquipe
});
if (equipes.length === 0) {
error(nomEquipe + " inconnue", msg.content);
return;
}
if (equipes.length > 1) {
error("Plus d'une " + nomEquipe, cmd);
}
count += equipes.length;
equipes.forEach(function(equipe) {
equipe.get('notes', function(note) { //asynchrone
var persos = charactersInHandout(note, nomEquipe);
var tokens = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
layer: 'objects'
});
var uneCible = false;
tokens.forEach(function(tok) {
var tokCharId = tok.get('represents');
if (persos.has(tokCharId)) {
uneCible = true;
selected.push({
_id: tok.id
});
}
});
if (!uneCible) {
error("Pas de token de l'" + nomEquipe + " sur la page");
}
count--;
if (count === 0) finalCall();
});
});
return;
case 'allies':
case 'saufAllies':
var selection = selected;
var saufAllies = (cmdSplit[0] == 'saufAllies');
if (saufAllies) selection = enleveAuxSelected;
var actives = [];
var allies = new Set();
// First get the acting token (in msg.selected)
if (actif) {
actives = [actif];
allies = alliesParPerso[actif.charId] || allies;
if (saufAllies) allies = (new Set(allies)).add(actif.charId);
} else {
if (msg.selected === undefined || msg.selected.length === 0) {
error("Pas d'allié car pas de token sélectionné", msg);
return;
}
iterSelected(msg.selected, function(personnage) {
actives.push(personnage);
var alliesPerso = alliesParPerso[personnage.charId];
if (alliesPerso) {
alliesPerso.forEach(function(ci) {
allies.add(ci);
});
}
if (saufAllies) allies.add(personnage.charId);
});
}
var tokens = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
layer: 'objects'
});
tokens.forEach(function(tok) {
var ci = tok.get('represents');
if (ci === '') return;
if (!allies.has(ci)) return;
//On enlève le token actif, mais seulement pour allies
if (cmdSplit[0] == 'allies') {
if (actives.indexOf(function(perso) {
return perso.charId == ci;
}) >= 0) return;
}
selection.push({
_id: tok.id
});
});
return;
case 'self':
if (actif) {
selected.push({
_id: actif.token.id
});
return;
}
if (msg.selected === undefined) return;
msg.selected.forEach(function(obj) {
var inSelf = selected.findIndex(function(o) {
return (o._id == obj._id);
});
if (inSelf < 0) selected.push(obj);
});
return;
case 'target':
if (cmdSplit.length < 2) {
error("Il manque l'id de la cible (après --target)", cmd);
return;
}
selected.push({
_id: cmdSplit[1]
});
return;
case 'disque':
if (cmdSplit.length < 3) {
error("Pas assez d'argument pour définir un disque", cmdSplit);
return;
}
var centre = tokenOfId(cmdSplit[1], cmdSplit[1], pageId);
if (centre === undefined) {
error("le premier argument du disque n'est pas un token valide", cmdSplit);
return;
}
var tokenCentre = centre.token;
var rayon = parseInt(cmdSplit[2]);
if (isNaN(rayon) || rayon < 0) {
error("Rayon du disque mal défini", cmdSplit);
return;
}
var portee;
if (cmdSplit.length > 3) {
portee = parseInt(cmdSplit[3]);
if (isNaN(portee) || portee < 0) {
error("La portée du disque est mal formée", cmdSplit);
return;
}
if (actif === undefined) {
if (msg.selected === undefined || msg.selected.length != 1) {
error("Pas de token sélectionné pour calculer la distance du disque", msg);
return;
}
actif = tokenOfId(msg.selected[0]._id, msg.selected[0]._id, pageId);
}
if (distanceCombat(tokenCentre, actif.token, pageId, {
strict1: true
}) > portee) {
sendChar(actif.charId, "Le centre de l'effet est placé trop loin (portée " + portee + " m)");
return;
}
}
var allToksDisque =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
allToksDisque.forEach(function(obj) {
if (portee === 0 && obj.id == actif.token.id) return; //on ne se cible pas si le centre de l'aoe est soi-même
var objCharId = obj.get('represents');
if (objCharId === '') return;
if (getState({
token: obj,
charId: objCharId
}, 'mort')) return; //pas d'effet aux morts
if (obj.get('bar1_max') == 0) return; // jshint ignore:line
var objChar = getObj('character', objCharId);
if (objChar === undefined) return;
var distanceCentre = distanceCombat(tokenCentre, obj, pageId, {
strict1: true
});
if (distanceCentre > rayon) return;
selected.push({
_id: obj.id
});
});
if (options.targetFx) {
spawnFx(tokenCentre.get('left'), tokenCentre.get('top'), options.targetFx, pageId);
}
if (tokenCentre.get('bar1_max') == 0) { // jshint ignore:line
//C'est juste un token utilisé pour définir le disque
tokenCentre.remove(); //On l'enlève, normalement plus besoin
delete options.targetFx;
}
return;
default:
}
});
}
if (count === 0) {
if (selected.length === 0) {
if (msg.selected) {
if (!called) {
var res = msg.selected.filter(function(sel) {
var interdit = enleveAuxSelected.find(function(i) {
return (i._id == sel._id);
});
return (interdit === undefined);
});
callback(res, playerId);
}
return;
}
if (!called) callback([], playerId);
return;
}
if (!called) finalCall();
}
}
//msg peut être directement le playerId ou un message
function getPlayerIdFromMsg(msg) {
if (msg.playerid === undefined) return msg;
var playerId = msg.playerid;
if (playerId == 'API') {
var nom = msg.who;
if (nom === undefined) return playerId;
nom = nom.replace(/ \(GM\)/, '');
//On regarde si un joueur s'appelle nom
var players = findObjs({
type: 'player',
displayname: nom
});
if (players.length === 0) {
var characters = findObjs({
type: 'character',
name: nom
});
if (characters.length === 0) {
error("Impossible de trouver l'id du joueur " + nom);
return playerId;
}
var pids = characters[0].get('controlledby');
pids = pids.split(',');
if (pids[0] == 'all') {
players = findObjs({
type: 'player'
});
playerId = players[0].id;
} else playerId = pids[0];
} else playerId = players[0].id;
}
return playerId;
}
//origin peut être un message ou un nom de joueur
function sendPlayer(origin, msg) {
var dest = origin;
if (origin.who) {
if (playerIsGM(getPlayerIdFromMsg(origin))) dest = 'GM';
else dest = origin.who;
}
sendChat('COF', '/w "' + dest + '" ' + msg);
}
function isCarac(x) {
switch (x) {
case 'FOR':
case 'DEX':
case 'CON':
case 'SAG':
case 'INT':
case 'CHA':
return true;
default:
return false;
}
}
function jet(msg) {
// Les arguments pour cof-jet sont :
// - Caracteristique (FOR, DEX, CON, INT, SAG, CHA)
// Les tokens sélectionnés sont ceux qui doivent faire le jet
var opts = msg.content.split(' --');
var cmd = opts.shift().split(' ');
var options = {
bonusAttrs: []
};
opts.forEach(function(o) {
var args = o.split(' ');
switch (args[0]) {
case "nom":
if (args.length < 2) {
error("Il manque un argument à l'option " + args[0], opts);
return;
}
options.nom = args[1];
options.bonusAttrs.push(args[1].toLowerCase());
return;
case "attribut":
if (args.length < 2) {
error("Il manque un argument à l'option " + args[0], opts);
return;
}
options.bonusAttrs.push(args[1]);
return;
case 'bonus':
if (args.length < 2) {
error("Il manque un argument à l'option " + args[0], opts);
return;
}
var bonus = parseInt(args[1]);
if (isNaN(bonus)) {
error("Le bonus doit être un nombre", opts);
return;
}
options.bonus = (options.bonus || 0) + bonus;
return;
case 'secret':
case 'competences':
options[args[0]] = true;
return;
}
});
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "!cof-jet sans sélection de token");
log("!cof-jet requiert de sélectionner des tokens");
return;
}
if (cmd.length < 2) { //On demande la carac et la compétence, si définies dans un handout Compétence
if (options.nom) {
error("Il manque la caractéristique à utiliser pour la compétence " + options.nom, msg.content);
return;
}
iterSelected(selected, function(perso) {
var display = startFramedDisplay(playerId, "Jet de caractéristique", perso, {
chuchote: true
});
startTableInFramedDisplay(display);
boutonsCompetences(display, perso, 'FOR', msg);
boutonsCompetences(display, perso, 'DEX', msg);
boutonsCompetences(display, perso, 'CON', msg);
boutonsCompetences(display, perso, 'SAG', msg);
boutonsCompetences(display, perso, 'INT', msg);
boutonsCompetences(display, perso, 'CHA', msg);
endTableInFramedDisplay(display);
sendChat('', endFramedDisplay(display));
}); //fin de iterSelected
return;
}
var caracteristique = cmd[1];
if (!isCarac(caracteristique)) {
error("Caracteristique '" + caracteristique + "' non reconnue (FOR, DEX, CON, INT, SAG, CHA).", cmd);
return;
}
if (options.competences && options.nom === undefined) {
iterSelected(selected, function(perso) {
var display = startFramedDisplay(playerId, "Jet de " + caracteristique, perso, {
chuchote: true
});
addLineToFramedDisplay(display, "Choisissez la compétence");
startTableInFramedDisplay(display);
boutonsCompetences(display, perso, caracteristique, msg);
endTableInFramedDisplay(display);
sendChat('', endFramedDisplay(display));
}); //fin de iterSelected
return;
}
var difficulte;
if (cmd.length > 2) {
difficulte = parseInt(cmd[2]);
if (isNaN(difficulte)) difficulte = undefined;
}
var titre = "Jet d";
var nomJet;
if (options.nom && options.nom.length > 0) {
nomJet = options.nom;
} else {
nomJet = caracOfMod(caracteristique).toLowerCase();
}
var nj = nomJet.toLowerCase();
switch (nj[0]) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
titre += "'<b>";
break;
default:
titre += "e <b>";
}
titre += nomJet;
titre += "</b>";
if (nj == 'perception') {
options.bonusAttrs = options.bonusAttrs || [];
options.bonusAttrs.push('diversionManoeuvreValeur');
}
if (options.bonus)
titre += " (" + ((options.bonus > 0) ? '+' : '') + options.bonus + ")";
if (difficulte !== undefined) titre += " difficulté " + difficulte;
iterSelected(selected, function(perso) {
jetPerso(perso, caracteristique, difficulte, titre, playerId, options);
}); //fin de iterSelected
}); //fin de getSelected
}
function resultatJet(msg) {
var args = msg.content.split(' ');
if (args.length < 3) {
error("La fonction !cof-resultat-jet n'a pas assez d'arguments", args);
return;
}
var evt = findEvent(args[1]);
if (evt === undefined) {
error("Le jet est trop ancien ou éte annulé", args);
return;
}
if (evt.personnage === undefined) {
error("Erreur interne ", evt);
return;
}
if (evt.attenteResultat) {
var message = evt.type + " ";
if (args[2] == 'rate') {
diminueMalediction(evt.personnage, evt);
message += "raté.";
} else message += "réussi.";
sendChar(evt.personnage.charId, message);
delete evt.attenteResultat;
} else {
sendPlayer(msg, "Résultat déjà décidé");
}
}
var tempeteDeManaCourante = {
vide: true
};
function ajouterOptionTempete(display, option, texte, restant, perso) {
var line = texte + " : ";
if (tempeteDeManaCourante[option])
line += bouton("!cof-tempete-de-mana -" + option, "Oui", perso);
else if (restant > 0)
line += bouton("!cof-tempete-de-mana " + option, "Non", perso);
else line += "Non";
addLineToFramedDisplay(display, line);
}
function optionsDeTempeteDeMana(msg) {
if (tempeteDeManaCourante.vide) {
error("Pas de tempête de mana en cours", tempeteDeManaCourante);
return;
}
var perso = tempeteDeManaCourante.perso;
var cmd = msg.content.split(' ');
if (cmd.length > 1) {
switch (cmd[1]) {
case 'duree':
case 'portee':
case 'rapide':
if (tempeteDeManaCourante[cmd[1]]) break;
tempeteDeManaCourante[cmd[1]] = true;
tempeteDeManaCourante.cout++;
break;
case '-duree':
case '-portee':
case '-rapide':
case '-altruiste':
var opt = cmd[1].substring(1);
if (tempeteDeManaCourante[opt]) {
tempeteDeManaCourante[opt] = false;
tempeteDeManaCourante.cout--;
}
break;
case 'altruiste':
if (cmd.length < 3) {
error("Il manque l'id du token pour l'option altruiste de la tempete de mana", cmd);
return;
}
var cible = tokenOfId(cmd[2]);
if (cmd[2] == perso.token.id) cible = undefined;
if (cible) {
if (!tempeteDeManaCourante.altruiste) tempeteDeManaCourante.cout++;
} else {
if (tempeteDeManaCourante.altruiste) tempeteDeManaCourante.cout--;
}
tempeteDeManaCourante.altruiste = cible;
break;
default:
var it = parseInt(cmd[1]);
if (isNaN(it) || it < 0) {
error("Argument de !cof-tempete-de-mana inconnu", cmd);
return;
}
if (tempeteDeManaCourante.intense === undefined)
tempeteDeManaCourante.intense = 0;
tempeteDeManaCourante.cout += it - tempeteDeManaCourante.intense;
tempeteDeManaCourante.intense = it;
}
}
var title = "Tempête de mana";
if (tempeteDeManaCourante.cout) {
title += " de puissance " + tempeteDeManaCourante.cout;
}
var restant = 100;
if (tempeteDeManaCourante.max) {
title += " (max " + tempeteDeManaCourante.max + ")";
restant = tempeteDeManaCourante.max - tempeteDeManaCourante.cout;
}
var display = startFramedDisplay(tempeteDeManaCourante.playerId, title, perso, {
chuchote: true
});
if (tempeteDeManaCourante.dureeDeBase &&
tempeteDeManaCourante.dm === undefined &&
tempeteDeManaCourante.soins === undefined)
ajouterOptionTempete(display, "duree", "Durée", restant, perso);
if (tempeteDeManaCourante.porteeDeBase)
ajouterOptionTempete(display, "portee", "Portée", restant, perso);
ajouterOptionTempete(display, "rapide", "Rapide", restant, perso);
if (tempeteDeManaCourante.altruistePossible) {
var la = 'Magie altruiste : ';
if (restant || tempeteDeManaCourante.altruiste) {
var tla = "Sélectionner";
if (tempeteDeManaCourante.altruiste) {
tla = tempeteDeManaCourante.altruiste.token.get('name');
}
la += bouton("!cof-tempete-de-mana altruiste @{target|token_id}", tla, perso);
} else la += 'Non';
addLineToFramedDisplay(display, la);
}
var line = "Magie intense :";
var magieIntense = 0;
if (tempeteDeManaCourante.intense)
magieIntense = tempeteDeManaCourante.intense;
var maxMagieIntense = magieIntense + restant;
if (maxMagieIntense > 5 && restant > 0) maxMagieIntense = magieIntense + 1;
for (var i = 0; i <= maxMagieIntense; i++) {
if (i == magieIntense) line += " " + i;
else line += " " + bouton("!cof-tempete-de-mana " + i, i, perso);
}
addLineToFramedDisplay(display, line);
var v = tempeteDeManaCourante.cmd;
var vopt = '';
if (tempeteDeManaCourante.cout) {
vopt = "--tempeteDeMana";
if (tempeteDeManaCourante.duree) vopt += " duree";
if (tempeteDeManaCourante.portee) vopt += " portee";
if (tempeteDeManaCourante.rapide) vopt += " rapide";
if (tempeteDeManaCourante.altruiste)
vopt += " altruiste " + tempeteDeManaCourante.altruiste.token.id;
if (tempeteDeManaCourante.intense)
vopt += " " + tempeteDeManaCourante.intense;
}
v = v.replace(/--tempeteDeMana/, vopt);
addLineToFramedDisplay(display, bouton(v, "Valider", perso));
sendChat("", endFramedDisplay(display));
}
function setTempeteDeMana(playerId, perso, cmd, options) {
tempeteDeManaCourante = {
perso: perso,
playerId: playerId,
cmd: cmd,
rapide: options.rapide,
dm: options.dm,
soins: options.soins,
intense: options.intense,
porteeDeBase: options.portee,
dureeDeBase: options.duree,
altruistePossible: options.altruiste,
cout: options.cout || 0
};
var max;
if (options.rang) max = options.rang;
var mana = options.mana || 0;
var niveau = ficheAttributeAsInt(perso, 'NIVEAU', 1);
var cout_par_effet = 1;
if (stateCOF.options.regles.val.mana_totale.val) cout_par_effet = 3;
if (max === undefined || max > niveau - (mana / cout_par_effet))
max = Math.floor(niveau - (mana / cout_par_effet));
if (max < 1) {
sendChar(perso.charId, "ne peut pas dépenser plus de mana en tempête de mana (niveau " + niveau + ", mana déjà dépensée " + mana + ")");
return;
}
tempeteDeManaCourante.max = max;
optionsDeTempeteDeMana({
content: '!cof-tempete-de-mana'
});
}
function parseTempeteDeMana(cmd, options) {
cmd.shift();
options.tempeteDeMana = {
cout: 0
};
var altruiste = false;
cmd.forEach(function(ta) {
switch (ta) {
case 'portee':
if (options.tempeteDeManaPortee) break;
options.tempeteDeMana.cout++;
options.tempeteDeManaPortee = true;
altruiste = false;
break;
case 'duree':
if (options.tempeteDeManaDuree) break;
options.tempeteDeMana.cout++;
options.tempeteDeManaDuree = true;
altruiste = false;
break;
case 'rapide':
options.tempeteDeMana.cout++;
break;
case 'altruiste':
options.altruiste = true;
altruiste = true;
break;
default:
if (altruiste) {
altruiste = false;
var cible = tokenOfId(ta);
if (cible) {
options.tempeteDeMana.cout++;
options.tempeteDeMana.altruiste = cible;
}
} else {
var intensite = parseInt(ta);
if (isNaN(ta) || ta <= 0) {
error("Option de tempête de mana " + ta + " non reconnue", cmd);
break;
}
options.tempeteDeManaIntense = options.tempeteDeManaIntense || 0;
options.tempeteDeManaIntense += intensite;
options.tempeteDeMana.cout += intensite;
}
}
});
options.mana = options.mana || 0;
if (stateCOF.options.regles.val.mana_totale.val)
options.mana += options.tempeteDeMana.cout * 3;
else options.mana += options.tempeteDeMana.cout;
}
function parseCondition(args) {
if (args.length > 0 && (args[0] == 'crit' || args[0] == 'critique')) {
return {
type: 'critique'
};
}
if (args.length < 2) {
error("condition non reconnue", args);
return undefined;
}
switch (args[0]) {
case "etat":
if (_.has(cof_states, args[1])) {
return {
type: 'etat',
etat: args[1],
text: args[1]
};
}
return {
type: 'attribut',
attribute: args[1],
text: args[1]
};
case "etatCible":
if (_.has(cof_states, args[1])) {
return {
type: 'etatCible',
etat: args[1],
text: args[1]
};
}
return {
type: 'attributCible',
attribute: args[1],
text: args[1]
};
case "deAttaque":
var valeurDeAttaque = parseInt(args[1]);
if (isNaN(valeurDeAttaque)) {
error("La condition de dé d'attaque doit être un nombre", args);
// on continue exprès pour tomber dans le cas par défaut
} else {
return {
type: 'deAttaque',
seuil: valeurDeAttaque,
text: args[1]
};
}
/* falls through */
default:
return {
type: args[0],
attribute: args[1],
text: args[1]
};
}
}
function closeIte(scope) {
var ps = scope.parentScope;
if (ps === undefined) return;
log("Il manque un endif");
delete scope.parentScope;
closeIte(ps);
}
function getFx(cmd, argName, obj, funName) {
if (cmd.length < 2) {
var errMsg = "Il manque un argument à l'option --" + argName;
if (funName) errMsg += " de " + funName;
sendChat("COF", errMsg);
return;
}
if (cmd[1] == 'custom' && cmd.length > 2) {
var effet = findObjs({
_type: 'custfx',
name: cmd[2]
});
if (effet.length === 0) {
sendChat("COF", "L'effet custom " + cmd[2] + " est inconnu.");
return;
}
obj[argName] = effet[0].id;
} else obj[argName] = cmd[1];
}
function parseAttack(msg) {
// Arguments to cof-attack should be:
// - attacking token
// - target token
// - attack number (referring to the character sheet)
// - some optional arguments, preceded by --
var optArgs = msg.content.split(" --");
var args = optArgs[0].split(" ");
optArgs.shift();
if (args.length < 4) {
error("Pas assez d'arguments pour !cof-attack: " + msg.content, args);
return;
}
var attaquant = tokenOfId(args[1]);
if (attaquant === undefined) {
error("Le premier argument de !cof-attack n'est pas un token valide" + msg.content, args[1]);
return;
}
var targetToken = getObj("graphic", args[2]);
if (targetToken === undefined) {
error("le second argument de !cof-attack doit être un token" + msg.content, args[2]);
return;
}
var attackLabel = args[3];
var playerId = getPlayerIdFromMsg(msg);
// Optional arguments
var options = {};
var lastEtat; //dernier de etats et effets
var scope = options; //Pour les conditionnelles
optArgs.forEach(function(arg) {
arg = arg.trim();
var cmd = arg.split(" ");
cmd = cmd.filter(function(c) {
return c !== '';
});
if (cmd.length === 0) cmd = [arg];
switch (cmd[0]) {
case "pressionMortelle":
case "ignoreRD":
case "ignoreMoitieRD":
case "tempDmg":
case "vampirise":
case "enflamme":
case "malediction":
case "pietine":
case "maxDmg":
case "ouvertureMortelle":
scope[cmd[0]] = true;
return;
case 'arc':
case 'arbalete':
case "affute":
case "armeDArgent":
case "artificiel":
case "asDeLaGachette":
case "attaqueMentale":
case "auto":
case "avecd12":
case "contondant":
case "demiAuto":
case "explodeMax":
case "feinte":
case "ignoreObstacles":
case "m2d20":
case "mainsDEnergie":
case "pasDeDmg":
case "percant":
case "pointsVitaux":
case "poudre":
case "metal":
case "reroll1":
case "reroll2":
case "semonce":
case "sortilege":
case "strigeSuce":
case "tirDeBarrage":
case "tranchant":
case "test":
case "traquenard":
case "tueurDeGeants":
case "grenaille":
case "attaqueArmeeConjuree":
case "difficultePVmax":
case "lamesJumelles":
case "riposte":
case 'secret':
case 'saufAllies':
case 'attaqueAssuree':
case 'attaqueRisquee':
options[cmd[0]] = true;
return;
case "imparable": //deprecated
options.m2d20 = true;
return;
case "tirDouble":
if (cmd.length > 1)
options.tirDouble = {
label: cmd[1]
};
else options.tirDouble = options.tirDouble || true;
return;
case "magique":
var niveauMagie = 1;
if (cmd.length > 1) {
niveauMagie = parseInt(cmd[1]);
if (isNaN(niveauMagie) || niveauMagie < 1) {
error("Le niveau de magie doit être au moins 1", cmd);
niveauMagie = 1;
}
}
options.magique = niveauMagie;
return;
case "si":
options.conditionAttaquant = parseCondition(cmd.slice(1));
return;
case 'tempsRecharge':
if (cmd.length < 3) {
error("Il manque un argument à l'option --tempsRecharge de !cof-attack", cmd);
return;
}
if (!estEffetTemp(cmd[1])) {
error("Le premier argument de l'option --tempsRecharge doit être un effet temporaire répertorié", cmd);
return;
}
var tr = parseInt(cmd[2]);
if (isNaN(tr)) {
error("Le deuxième argument de l'option --tempsRecharge doit être un nombre", cmd);
return;
}
options.tempsRecharge = {
effet: cmd[1],
duree: tr
};
return;
case "plus":
if (cmd.length < 2) {
error("Il manque un argument à l'option --plus de !cof-attack", cmd);
return;
}
var val = arg.substring(arg.indexOf(' ') + 1);
scope.additionalDmg = scope.additionalDmg || [];
scope.additionalDmg.push({
value: val
});
break;
case "effet":
if (cmd.length < 2) {
error("Il manque un argument à l'option --effet de !cof-attack", cmd);
return;
}
if (estEffetTemp(cmd[1])) {
if (cmd.length < 3) {
error("Il manque un argument à l'option --effet de !cof-attack", cmd);
return;
}
var duree;
duree = parseInt(cmd[2]);
if (isNaN(duree) || duree < 1) {
error(
"Le deuxième argument de --effet doit être un nombre positif",
cmd);
return;
}
var m = messageOfEffetTemp(cmd[1]);
lastEtat = {
effet: cmd[1],
duree: duree,
message: m
};
scope.seulementVivant = m && m.seulementVivant;
} else if (estEffetCombat(cmd[1])) {
lastEtat = {
effet: cmd[1]
};
} else {
error(cmd[1] + " n'est pas un effet temporaire répertorié", cmd);
return;
}
scope.effets = scope.effets || [];
scope.effets.push(lastEtat);
return;
case 'valeur':
if (cmd.length < 2) {
error("Il manque un argument à l'option --valeur de !cof-attack", cmd);
return;
}
if (scope.effets === undefined || scope.effets.length === 0) {
error("Il faut un effet avant l'option --valeur", optArgs);
return;
}
scope.effets[0].valeur = cmd[1];
if (cmd.length > 2) scope.effets[0].valeurMax = cmd[2];
return;
case "etatSi":
case "etat":
if (cmd.length < 3 && cmd[0] == 'etatSi') {
error("Il manque un argument à l'option --etatSi de !cof-attack", cmd);
return;
} else if (cmd.length < 2) {
error("Il manque un argument à l'option --etat de !cof-attack", cmd);
return;
}
var etat = cmd[1];
if (!_.has(cof_states, etat)) {
error("Etat non reconnu", cmd);
return;
}
var condition = 'toujoursVrai';
if (cmd[0] == 'etatSi') {
condition = parseCondition(cmd.slice(2));
if (condition === undefined) return;
}
scope.etats = scope.etats || [];
lastEtat = {
etat: etat,
condition: condition
};
if (cmd[0] == 'etat' && cmd.length > 3) {
if (isCarac(cmd[2])) {
lastEtat.saveCarac = cmd[2];
var opposition = tokenOfId(cmd[3]);
if (opposition) {
lastEtat.saveDifficulte = cmd[3] + ' ' + opposition.token.get('name');
} else {
lastEtat.saveDifficulte = parseInt(cmd[3]);
if (isNaN(lastEtat.saveDifficulte)) {
error("Difficulté du jet de sauvegarde incorrecte", cmd);
delete lastEtat.saveCarac;
delete lastEtat.saveDifficulte;
}
}
}
}
scope.etats.push(lastEtat);
return;
case "psi": //deprecated
var psil = 0;
if (scope.adiitionalDmg) psil = scope.additionalDmg.length;
if (psil === 0) {
error("option --psi non précédée d'un --plus", optArgs);
return;
}
var psiCond = parseCondition(cmd.slice(1));
if (psiCond) {
var psiDmg = scope.additionalDmg[psil - 1];
psiDmg.conditions = psiDmg.conditions || [];
psiDmg.conditions.push(psiCond);
}
return;
case "peur":
if (cmd.length < 3) {
error("Il manque un argument à l'option --peur de !cof-attack", cmd);
return;
}
scope.peur = {
seuil: parseInt(cmd[1]),
duree: parseInt(cmd[2])
};
if (isNaN(scope.peur.seuil)) {
error("Le premier argument de --peur doit être un nombre (le seuil)", cmd);
}
if (isNaN(scope.peur.duree) || scope.peur.duree <= 0) {
error("Le deuxième argument de --peur doit être un nombre positif (la durée)", cmd);
}
return;
case "feu":
case "froid":
case "acide":
case "electrique":
case "sonique":
case "poison":
case "maladie":
case "argent":
var l = 0;
if (scope.additionalDmg) l = scope.additionalDmg.length;
if (l > 0) {
scope.additionalDmg[l - 1].type = cmd[0];
} else {
scope.type = cmd[0];
}
return;
case "nature":
case "naturel":
scope.nature = true;
return;
case "sournoise":
case "de6Plus": //deprecated
if (cmd.length < 2) {
sendChat("COF", "Il manque un argument à l'option --sournoise de !cof-attack");
return;
}
if (scope.sournoise === undefined) scope.sournoise = 0;
scope.sournoise += parseInt(cmd[1]);
if (isNaN(scope.sournoise) || scope.sournoise < 0) {
error("L'option --sournoise de !cof-attack attend un argument entier positif", cmd);
return;
}
break;
case "fx":
getFx(cmd, 'fx', scope, '!cof-attack');
return;
case "targetFx":
getFx(cmd, 'targetFx', scope, '!cof-attack');
return;
case 'psave':
var psaveopt = scope;
if (cmd.length > 3 && cmd[3] == 'local') {
var psavel = 0;
if (scope.additionalDmg) psavel = scope.additionalDmg.length;
if (psavel > 0) {
psaveopt = scope.additionalDmg[psavel - 1];
}
}
var psaveParams = parseSave(cmd);
if (psaveParams) {
psaveopt.partialSave = psaveParams;
psaveopt.attaquant = attaquant;
}
return;
case 'save':
if (lastEtat) {
if (lastEtat.save) {
error("Redéfinition de la condition de save pour un effet", optArgs);
}
var saveParams = parseSave(cmd);
if (saveParams) {
lastEtat.save = saveParams;
return;
}
return;
}
error("Pas d'effet auquel appliquer le save", optArgs);
return;
case 'saveParTour':
if (lastEtat) {
if (lastEtat.saveParTour) {
error("Redéfinition de la condition de save pour un effet", optArgs);
}
var saveParTourParams = parseSave(cmd);
if (saveParTourParams) {
lastEtat.saveParTour = saveParTourParams;
return;
}
return;
}
error("Pas d'effet auquel appliquer le save", optArgs);
return;
case "mana":
if (cmd.length < 2) {
error("Usage : --mana coût", cmd);
return;
}
var mana = parseInt(cmd[1]);
if (isNaN(mana) || mana < 1) {
error("Le coût en mana doit être un nombre positif");
return;
}
if (scope.mana === undefined) scope.mana = 0;
scope.mana += mana;
break;
case "tempeteDeMana":
parseTempeteDeMana(cmd, options);
return;
case "rang":
if (cmd.length < 2) {
error("Usage : --rang r", cmd);
return;
}
var rang = parseInt(cmd[1]);
if (isNaN(rang) || rang < 1) {
error("Le rang doit être un nombre positif");
return;
}
scope.rang = rang;
break;
case "bonusAttaque":
case "bonusContreBouclier":
if (cmd.length < 2) {
error("Usage : --" + cmd[0] + " b", cmd);
return;
}
var bAtt = parseInt(cmd[1]);
if (isNaN(bAtt)) {
error("Le bonus (" + cmd[0] + ") doit être un nombre");
return;
}
if (scope[cmd[0]] === undefined) scope[cmd[0]] = 0;
scope[cmd[0]] += bAtt;
return;
case "bonusCritique":
if (cmd.length < 2) {
error("Usage : --" + cmd[0] + " b", cmd);
return;
}
var b2Att = parseInt(cmd[1]);
if (isNaN(b2Att)) {
error("Le bonus (" + cmd[0] + ") doit être un nombre");
return;
}
if (options[cmd[0]] === undefined) options[cmd[0]] = 0;
options[cmd[0]] += b2Att;
return;
case 'puissant':
if (cmd.length < 2) {
scope.puissant = true;
return;
}
switch (cmd[1]) {
case 'oui':
case 'Oui':
scope.puissant = true;
return;
case 'non':
case 'Non':
scope.puissant = false;
return;
case 'duree':
scope.puissantDuree = true;
return;
default:
scope.puissant = attributeAsBool(attaquant, cmd[1] + "Puissant");
}
return;
case "rate":
case "touche":
case "critique":
case "echecCritique":
if (options.triche === undefined) {
options.triche = cmd[0];
} else {
error("Option incompatible", optArgs);
}
return;
case 'munition':
if (cmd.length < 2) {
error("Pour les munitions, il faut préciser le nom", cmd);
return;
}
var tauxPertes = 100; //Par défaut, les munitions sont perdues
if (cmd.length > 2)
tauxPertes = parseInt(cmd[2]);
if (isNaN(tauxPertes) || tauxPertes < 0 || tauxPertes > 100) {
error("Le taux de pertes des munitions doit être un nombre entre 0 et 100");
tauxPertes = 100;
}
options.munition = {
nom: cmd[1],
taux: tauxPertes
};
return;
case "ligne":
if (options.aoe) {
error("Deux options pour définir une aoe", args);
return;
}
options.aoe = {
type: 'ligne'
};
return;
case "disque":
if (options.aoe) {
error("Deux options pour définir une aoe", args);
return;
}
if (cmd.length < 2) {
error("Il manque le rayon du disque", cmd);
return;
}
options.aoe = {
type: 'disque',
rayon: parseInt(cmd[1])
};
if (isNaN(options.aoe.rayon) || options.aoe.disque < 0) {
error("le rayon du disque n'est pas un nombre positif", cmd);
delete options.aoe;
}
return;
case "cone":
if (options.aoe) {
error("Deux options pour définir une aoe", args);
return;
}
var angle = 90;
if (cmd.length > 1) {
angle = parseInt(cmd[1]);
if (isNaN(angle) || angle < 0 || angle > 360) {
error("Paramètre d'angle du cone incorrect", cmd);
angle = 90;
}
}
options.aoe = {
type: 'cone',
angle: angle
};
return;
case 'target':
if (cmd.length < 2) {
error("Il manque l'id de la cible", cmd);
return;
}
var targetS = tokenOfId(cmd[1]);
if (targetS === undefined) {
error("Cible supplémentaire invalide", cmd);
return;
}
if (targetToken.id == targetS.token.id) return;
targetS.tokName = targetS.token.get('name');
options.ciblesSupplementaires = options.ciblesSupplementaires || [];
options.ciblesSupplementaires.push(targetS);
return;
case 'limiteParJour':
if (cmd.length < 2) {
error("Il manque la limite journalière", cmd);
return;
}
var limiteParJour = parseInt(cmd[1]);
if (isNaN(limiteParJour) || limiteParJour < 1) {
error("La limite journalière doit être un nombre positif", cmd);
return;
}
scope.limiteParJour = limiteParJour;
if (cmd.length > 2) {
cmd.splice(0, 2);
scope.limiteParJourRessource = cmd.joins('_');
}
return;
case 'limiteParCombat':
if (cmd.length < 2) {
scope.limiteParCombat = 1;
return;
}
var limiteParCombat = parseInt(cmd[1]);
if (isNaN(limiteParCombat) || limiteParCombat < 1) {
error("La limite par combat doit être un nombre positif", cmd);
return;
}
scope.limiteParCombat = limiteParCombat;
if (cmd.length > 2) {
cmd.splice(0, 2);
scope.limiteParCombatRessource = cmd.join('_');
}
return;
case 'decrAttribute':
if (cmd.length < 2) {
error("Erreur interne d'une commande générée par bouton", cmd);
return;
}
var attr = getObj('attribute', cmd[1]);
if (attr === undefined) {
attr = tokenAttribute(attaquant, cmd[1]);
if (attr.length === 0) {
log("Attribut à changer perdu");
log(cmd);
return;
}
attr = attr[0];
}
scope.decrAttribute = attr;
return;
case "incrDmgCoef":
scope.dmgCoef = (scope.dmgCoef || 1);
if (cmd.length > 1) {
var incrDmgCoef = parseInt(cmd[1]);
if (isNaN(incrDmgCoef)) {
error("L'option --incrDmgCoef attend un entier", cmd);
return;
}
scope.dmgCoef += incrDmgCoef;
return;
}
scope.dmgCoef++; //Par défaut, incrémente de 1
return;
case "incrCritCoef":
scope.critCoef = (scope.critCoef || 1);
if (cmd.length > 1) {
var incrCritCoef = parseInt(cmd[1]);
if (isNaN(incrCritCoef)) {
error("L'option --incrCritCoef attend un entier", cmd);
return;
}
scope.critCoef += incrCritCoef;
return;
}
scope.critCoef++; //Par défaut, incrémente de 1
return;
case "if":
var ifCond = parseCondition(cmd.slice(1));
if (ifCond === undefined) return;
var ifThen = {
parentScope: scope
};
scope.ite = scope.ite || [];
scope.ite.push({
condition: ifCond,
then: ifThen
});
scope = ifThen;
return;
case "endif":
var psEndif = scope.parentScope;
if (psEndif === undefined) {
error("--endIf sans --if correspondant", cmd);
return;
}
delete scope.parentScope; //To remove circular dependencies in options
scope = psEndif;
return;
case "else":
var psElse = scope.parentScope;
if (psElse === undefined) {
error("--else sans --if correspondant", cmd);
return;
}
var iteL = psElse.ite[psElse.ite.length - 1];
if (iteL.else) {
error("Il y a déjà un --else pour ce --if", cmd);
return;
}
delete scope.parentScope;
var ifElse = {
parentScope: psElse
};
iteL.else = ifElse;
scope = ifElse;
return;
case 'message':
if (cmd.length < 2) {
error("Il manque le message après --message", cmd);
return;
}
scope.messages = scope.messages || [];
scope.messages.push(cmd.slice(1).join(' '));
return;
case 'allonge':
if (cmd.length < 2) {
error("Il manque le message après --allonge", cmd);
return;
}
if (options.allonge !== undefined) {
log("Redéfinition de l'allong");
}
options.allonge = parseFloat(cmd[1]);
if (isNaN(options.allonge)) {
error("L'argument de --allonge n'est pas un nombre", cmd);
}
return;
case 'enveloppe':
scope.enveloppe = {
difficulte: 15,
type: 'label',
expression: attackLabel
};
if (cmd.length > 1) {
scope.enveloppe.difficulte = parseInt(cmd[1]);
if (isNaN(scope.enveloppe.difficulte))
scope.enveloppe.difficulte = 15;
}
if (cmd.length > 3) {
scope.enveloppe.type = cmd[2];
scope.enveloppe.expression = cmd[3];
}
return;
default:
sendChat("COF", "Argument de !cof-attack '" + arg + "' non reconnu");
}
});
closeIte(scope); //pour fermer les endif mal formés et éviter les boucles
options.additionalDmg = options.additionalDmg || [];
if (options.tempeteDeMana) {
if (options.tempeteDeMana.cout === 0) {
//On demande de préciser les options
var optMana = {
mana: options.mana,
rang: options.rang,
portee: true //Pour avoir l'option
};
if (!options.pasDeDmg) optMana.dm = true;
if (options.effets) {
options.effets.forEach(function(ef) {
if (ef.effet) {
if (estEffetTemp(ef.effet)) {
optMana.dm = optMana.dm || (ef.message && ef.message.dm);
optMana.soins = optMana.soins || (ef.message && ef.message.soins);
optMana.duree = true;
}
} else if (estEffetCombat(ef.effet)) {
optMana.dm = optMana.dm || messageEffetCombat[ef.effet].dm;
optMana.soins = optMana.soins || messageEffetCombat[ef.effet].soins;
}
});
}
setTempeteDeMana(playerId, attaquant, msg.content, optMana);
return;
} else {
if (options.rang && options.tempeteDeMana.cout > options.rang) {
sendChar(attaquant.charId, "Attention, le coût de la tempête de mana (" + options.tempeteDeMana.cout + ") est supérieur au rang du sort");
}
}
}
if (options.tempeteDeManaDuree || options.puissantDuree) {
if (options.pasDeDmg) {
if (options.peur && options.peur.duree)
options.peur.duree = options.peur.duree * 2;
if (options.effets) {
options.effets.forEach(function(ef) {
if (ef.effet && ef.duree && !ef.message.dm && !ef.message.soins) {
ef.duree = ef.duree * 2;
}
});
}
} else {
if (options.tempeteDeManDuree) {
sendChar(attaquant.charId, "Attention, l'option tempête de mana pour la durée n'est pas prise en compte. Utiliser l'option --pasDeDmg si le sort ne fait pas de DM");
options.tempeteDeManaDuree = false;
if (options.tempeteDeMana && options.tempeteDeMana.cout)
options.tempeteDeMana.cout--;
if (options.mana) {
if (stateCOF.options.regles.val.mana_totale.val) options.mana -= 3;
else options.mana--;
}
}
}
}
attack(playerId, attaquant, targetToken, attackLabel, options);
}
//Si evt est défini, alors on considère qu'il faut y mettre la valeur actuelle
function updateCurrentBar(token, barNumber, val, evt, maxVal) {
var prevToken;
var HTdeclared;
try {
HTdeclared = HealthColors;
} catch (e) {
if (e.name != "ReferenceError") throw (e);
}
if (HTdeclared) {
//Pour pouvoir annuler les effets de HealthColor sur le statut
affectToken(token, 'statusmarkers', token.get('statusmarkers'), evt);
prevToken = JSON.parse(JSON.stringify(token));
}
var fieldv = 'bar' + barNumber + '_value';
var fieldm;
if (maxVal) fieldm = 'bar' + barNumber + '_max';
var attrId = token.get("bar" + barNumber + "_link");
if (attrId === "") {
var prevVal = token.get(fieldv);
if (evt) affectToken(token, fieldv, prevVal, evt);
token.set(fieldv, val);
if (maxVal) {
var prevMax = token.get(fieldm);
if (evt) affectToken(token, fieldm, token.get(fieldm), evt);
token.set(fieldm, val);
}
if (HTdeclared) HealthColors.Update(token, prevToken);
return;
}
var attr = getObj('attribute', attrId);
if (evt) {
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attr,
current: attr.get('current'),
max: attr.get('max')
});
}
attr.set('current', val);
if (maxVal) attr.set('max', maxVal);
if (HTdeclared) HealthColors.Update(token, prevToken);
}
// Fait dépenser de la mana, et si pas possible, retourne false
function depenseMana(personnage, cout, msg, evt) {
if (isNaN(cout) || cout === 0) return true;
var token = personnage.token;
var charId = personnage.charId;
var manaAttr = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'PM'
}, {
caseInsensitive: true
});
var hasMana = false;
if (manaAttr.length > 0) {
var manaMax = parseInt(manaAttr[0].get('max'));
hasMana = !isNaN(manaMax) && manaMax > 0;
}
if (hasMana) {
var bar2 = parseInt(token.get("bar2_value"));
if (isNaN(bar2)) {
if (token.get('bar1_link') === '') bar2 = 0;
else { //devrait être lié à la mana courante
sendChar(charId, "*** Attention, la barre de mana du token n'est pas liée à la mana de la fiche ***");
bar2 = parseInt(manaAttr[0].get('current'));
}
}
if (bar2 < cout) {
msg = msg || '';
sendChar(charId, " n'a pas assez de points de mana pour " + msg);
return false;
}
updateCurrentBar(token, 2, bar2 - cout, evt);
var niveau = ficheAttributeAsInt(personnage, 'NIVEAU', 1);
if (stateCOF.options.regles.val.mana_totale.val) {
if (cout > niveau * 3) {
sendChar(charId, "Attention, la dépense totale de mana est supérieure au niveau * 3");
}
} else {
if (cout > niveau) {
sendChar(charId, "Attention, la dépense totale de mana est supérieure au niveau");
}
}
return true;
}
sendChar(charId, " n'a pas de points de mana, action impossible");
return false;
}
function parseSave(cmd) {
if (cmd.length < 3) {
error("Usage : --save carac seuil", cmd);
return;
}
var carac1;
var carac2;
if (cmd[1].length == 3) {
carac1 = cmd[1];
if (!isCarac(cmd[1])) {
error("Le premier argument de save n'est pas une caractéristique", cmd);
return;
}
} else if (cmd[1].length == 6) { //Choix parmis 2 caracs
carac1 = cmd[1].substr(0, 3);
carac2 = cmd[1].substr(3, 3);
if (!isCarac(carac1) || !isCarac(carac2)) {
error("Le premier argument de save n'est pas une caractéristique", cmd);
return;
}
} else {
error("Le premier argument de save n'est pas une caractéristique", cmd);
return;
}
var res = {
carac: carac1,
carac2: carac2,
seuil: parseInt(cmd[2])
};
if (isNaN(res.seuil)) {
error("Le deuxième argument de --psave n'est pas un nombre", cmd);
return;
}
if (cmd.length > 3) {
switch (cmd[3]) {
case 'carac':
case 'carac2':
case 'seuil':
error("Argument supplémentaire de save inconnu", cmd);
break;
default:
res[cmd[3]] = true;
}
}
return res;
}
function testCondition(cond, attaquant, cibles, deAttaque) {
if (cond == 'toujoursVrai') return true;
switch (cond.type) {
case "moins":
// Au cas où on utilise les MOD au lieu de l'attribut de base:
var attribute = caracOfMod(cond.attribute);
if (attribute) cond.attribute = attribute;
var attackerAttr = charAttributeAsInt(attaquant, cond.attribute, 0);
var resMoins = true;
cibles.forEach(function(target) {
if (resMoins) {
var targetAttr = charAttributeAsInt(target, cond.attribute, 0);
if (targetAttr >= attackerAttr) resMoins = false;
}
});
return resMoins;
case "etat":
return (getState(attaquant, cond.etat));
case "etatCible":
var resEtatCible = true;
cibles.forEach(function(target) {
if (resEtatCible && !getState(target, cond.etat))
resEtatCible = false;
});
return resEtatCible;
case "attribut":
return (attributeAsBool(attaquant, cond.attribute));
case "attributCible":
var resAttrCible = true;
cibles.forEach(function(target) {
if (resAttrCible && !attributeAsBool(target, cond.attribute))
resAttrCible = false;
});
return resAttrCible;
case "deAttaque":
if (deAttaque === undefined) {
error("Condition de dé d'attaque non supportée ici", cond);
return true;
}
return deAttaque >= cond.seuil;
case "critique":
return cibles.every(function(target) {
return target.critique;
});
default:
error("Condition non reconnue", cond);
}
return false;
}
//Evaluation récursive des if-then-else
function evalITE(attaquant, target, deAttaque, options, evt, explications, scope, inTarget) {
if (scope.ite === undefined) return;
scope.ite = scope.ite.filter(function(ite) {
var condInTarget = inTarget;
var resCondition;
if (ite.condition == 'toujoursVrai') resCondition = true;
switch (ite.condition.type) {
case 'etat':
case 'attribut':
resCondition = testCondition(ite.condition, attaquant, [], deAttaque);
break;
case 'deAttaque':
if (deAttaque === undefined) return true;
resCondition = testCondition(ite.condition, attaquant, [], deAttaque);
break;
case 'moins':
case 'etatCible':
case 'attributCible':
if (target === undefined) return true;
condInTarget = true;
resCondition = testCondition(ite.condition, attaquant, [target], deAttaque);
break;
case 'critique':
if (target === undefined || deAttaque === undefined) return true;
condInTarget = true;
resCondition = testCondition(ite.condition, attaquant, [target], deAttaque);
break;
default:
error("Condition non reconnue", ite.condition);
resCondition = true;
}
var branch;
if (resCondition) branch = ite.then;
else branch = ite.else;
if (branch === undefined) return condInTarget; //On garde l'ite si on dépende de la cible
//On copie les champs de scope dans options ou dans target
var opt = options;
if (condInTarget) opt = target;
for (var field in branch) {
switch (field) {
case 'additionalDmg':
case 'effets':
case 'etats':
opt[field] = opt[field] || [];
opt[field] = opt[field].concat(branch[field]);
break;
case 'sournoise':
case 'mana':
case 'bonusAttaque':
case 'bonusContreBouclier':
opt[field] = opt[field] || 0;
opt[field] += branch[field];
break;
case 'dmgCoef':
case 'critCoef':
if (opt[field] === undefined) {
if (condInTarget) opt[field] = 0;
else opt[field] = 1;
}
opt[field] += branch[field] - 1;
break;
case 'messages':
if (condInTarget) target.messages.concat(branch.messages);
else { /*jshint loopfunc: true */
branch.messages.forEach(function(m) {
explications.push(m);
});
}
break;
case 'decrAttribute':
var attr = branch.decrAttribute;
var oldval = parseInt(attr.get('current'));
if (isNaN(oldval) || oldval < 1) {
sendChar(attr.get('characterid'), "ne peut plus faire cela");
break;
}
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attr,
current: oldval,
max: attr.get('max')
});
attr.set('current', oldval - 1);
break;
default:
opt[field] = branch[field];
}
}
evalITE(attaquant, target, deAttaque, options, evt, explications, branch, condInTarget);
return condInTarget;
});
}
// evt et msg peuvent être undefined
function removeTokenAttr(personnage, attribute, evt, msg) {
var charId = personnage.charId;
var token = personnage.token;
// check if the token is linked to the character. If not, use token name
// in attribute name (token ids don't persist over API reload)
if (token) {
var link = token.get('bar1_link');
if (link === '') attribute += "_" + token.get('name');
}
var attr = findObjs({
_type: 'attribute',
_characterid: charId,
name: attribute
});
if (attr.length === 0) return;
if (msg !== undefined) {
sendChar(charId, msg);
}
attr = attr[0];
if (evt) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attr);
}
attr.remove();
}
function removeAllAttributes(name, evt, attrs) {
if (attrs === undefined) {
attrs = findObjs({
_type: 'attribute'
});
}
var attrsNamed = allAttributesNamed(attrs, name);
if (attrsNamed.length === 0) return attrs;
if (evt.deletedAttributes === undefined) evt.deletedAttributes = [];
attrsNamed.forEach(function(attr) {
evt.deletedAttributes.push(attr);
attr.remove();
});
attrs = attrs.filter(function(attr) {
var ind = attrsNamed.findIndex(function(nattr) {
return nattr.id == attr.id;
});
return (ind == -1);
});
return attrs;
}
function onGenre(charId, male, female) {
var sex = getAttrByName(charId, 'SEXE');
if (sex.startsWith('F')) return female;
return male;
}
function getValeurOfEffet(perso, effet, def, attrDef) {
var attrsVal = tokenAttribute(perso, effet + "Valeur");
if (attrsVal.length === 0) {
if (attrDef) return charAttributeAsInt(perso, attrDef, def);
return def;
}
var res = parseInt(attrsVal[0].get('current'));
if (isNaN(res)) return def;
return res;
}
function tokenInit(perso, evt) {
var persoMonte = tokenAttribute(perso, 'estMontePar');
if (persoMonte.length > 0) {
var cavalier = tokenOfId(persoMonte[0].get('current'), persoMonte[0].get('max'), perso.token.get('pageid'));
if (cavalier !== undefined) return tokenInit(cavalier, evt);
}
var init;
if (getAttrByName(perso.charId, 'type_personnage') == 'PNJ') {
init = ficheAttributeAsInt(perso, 'pnj_init', 10);
} else {
init = ficheAttributeAsInt(perso, 'DEXTERITE', 10);
init += ficheAttributeAsInt(perso, 'INIT_DIV', 0);
}
if (attributeAsBool(perso, 'formeDArbre')) init = 7;
//Règle optionelle : +1d6, à lancer en entrant en combat
if (stateCOF.options.regles.val.initiative_variable.val) {
var bonusVariable = attributeAsInt(perso, 'bonusInitVariable', 0);
if (bonusVariable === 0) {
var rollD6 = rollDePlus(6, {
deExplosif: true
});
bonusVariable = rollD6.val;
var msg = "entre en combat. ";
msg += onGenre(perso.charId, 'Il', 'Elle') + " fait " + rollD6.roll;
msg += " à son jet d'initiative";
setTokenAttr(perso, 'bonusInitVariable', bonusVariable, evt, msg);
}
init += bonusVariable;
}
if (getState(perso, 'aveugle')) init -= 5;
// Voie du compagnon animal rang 2 (surveillance)
init += attributeAsInt(perso, 'bonusInitEmbuscade', 0);
// Familier
if (familier(perso)) init += 2;
// Sixième sens en sort
if (attributeAsBool(perso, 'sixiemeSens')) init += 2;
// Voie du chef d'armée rang 2 (Capitaine)
if (aUnCapitaine(perso, evt)) init += 2;
if (charAttributeAsBool(perso, 'graceFeline')) {
init += modCarac(perso, 'CHARISME');
}
if (attributeAsBool(perso, 'masqueDuPredateur')) {
init += getValeurOfEffet(perso, 'masqueDuPredateur', modCarac(perso, 'SAGESSE'));
}
if (charAttributeAsBool(perso, 'controleDuMetabolisme')) {
init += getValeurOfEffet(perso, 'controleDuMetabolisme', modCarac(perso, 'CHARISME'));
}
if (attributeAsBool(perso, 'cadavreAnime')) {
init -= 2;
}
// Voie du pistolero rang 1 (plus vite que son ombre)
var armeEnMain = tokenAttribute(perso, 'armeEnMain');
if (armeEnMain.length > 0) {
var armeL = armeEnMain[0].get('current');
if (charAttributeAsInt(perso, "charge_" + armeL, 0) > 0) {
init += charAttributeAsInt(perso, 'initEnMain' + armeL, 0);
}
}
return init;
}
function initiative(selected, evt, recompute) { //set initiative for selected tokens
// Always called when entering combat mode
// set the initiative counter, if not yet set
// Assumption: all tokens that have not acted yet are those before the turn
// counter.
// When initiative for token not present, assumes it has not acted
// When present, stays in same group, but update position according to
// current initiative.
// Tokens appearing before the turn are sorted
if (!Campaign().get('initiativepage')) evt.initiativepage = false;
if (!stateCOF.combat) { //actions de début de combat
evt.combat = false;
evt.combat_pageid = stateCOF.combat_pageid;
stateCOF.combat = true;
Campaign().set({
turnorder: JSON.stringify([{
id: "-1",
pr: 1,
custom: "Tour",
formula: "+1"
}]),
initiativepage: true
});
evt.tour = stateCOF.tour;
stateCOF.tour = 1;
evt.init = stateCOF.init;
stateCOF.init = 1000;
removeAllAttributes('transeDeGuérison', evt);
}
if (!Campaign().get('initiativepage')) {
Campaign().set('initiativepage', true);
}
var to = getTurnOrder(evt);
if (to.pasAgi.length === 0) { // Fin de tour, on met le tour à la fin et on retrie
to.pasAgi = to.dejaAgi;
to.dejaAgi = [];
}
iterSelected(selected, function(perso) {
stateCOF.combat_pageid = perso.token.get('pageid');
if (!isActive(perso)) return;
var init = tokenInit(perso, evt);
// On place le token à sa place dans la liste du tour
var dejaIndex =
to.dejaAgi.findIndex(function(elt) {
return (elt.id == perso.token.id);
});
if (dejaIndex == -1) { //Le personnage doit encore agir
var push = true;
to.pasAgi =
to.pasAgi.filter(function(elt) {
if (elt.id == perso.token.id) {
if (recompute) return false; //On enlève le perso des pasAgi
push = false; //Sinon, comme on ne recalcule pas, on le laisse
return true;
}
return true;
});
if (push)
to.pasAgi.push({
id: perso.token.id,
pr: init,
custom: ''
});
} else {
to.dejaAgi[dejaIndex].pr = init;
}
});
setTurnOrder(to, evt);
}
function initPerso(personnage, evt, recompute) {
initiative([{
_id: personnage.token.id
}], evt, recompute);
}
function setFicheAttr(personnage, attribute, value, evt, msg, maxval) {
var charId = personnage.charId;
if (msg !== undefined) {
sendChar(charId, msg);
}
evt.attributes = evt.attributes || [];
var attr = findObjs({
_type: 'attribute',
_characterid: charId,
name: attribute
}, {
caseInsensitive: true
});
if (attr.length === 0) {
if (maxval === undefined) maxval = '';
attr = createObj('attribute', {
characterid: charId,
name: attribute,
current: value,
max: maxval
});
evt.attributes.push({
attribute: attr,
current: null
});
return attr;
}
attr = attr[0];
evt.attributes.push({
attribute: attr,
current: attr.get('current'),
max: attr.get('max')
});
attr.set('current', value);
if (maxval !== undefined) attr.set('max', maxval);
return attr;
}
// bonus d'attaque d'un token, indépendament des options
// Mise en commun pour attack et attaque-magique
function bonusDAttaque(personnage, explications, evt) {
explications = explications || [];
var charId = personnage.charId;
var tempAttkMod; // Utilise la barre 3 de l'attaquant
tempAttkMod = parseInt(personnage.token.get("bar3_value"));
if (tempAttkMod === undefined || isNaN(tempAttkMod) || tempAttkMod === "") {
tempAttkMod = 0;
}
var attBonus = tempAttkMod;
var fortifie = attributeAsInt(personnage, 'fortifie', 0);
if (fortifie > 0) {
attBonus += 3;
fortifie--;
explications.push("Effet du fortifiant => +3 en Attaque. Il sera encore actif pour " + fortifie + " tests");
if (fortifie === 0) {
removeTokenAttr(personnage, 'fortifie', evt);
} else {
setTokenAttr(personnage, 'fortifie', fortifie, evt);
}
}
attBonus += charAttributeAsInt(personnage, 'actionConcertee', 0);
if (attributeAsBool(personnage, 'chantDesHeros')) {
var bonusChantDesHeros = getValeurOfEffet(personnage, 'chantDesHeros', 1);
var chantDesHerosIntense = attributeAsInt(personnage, 'chantDesHerosTempeteDeManaIntense', 0);
bonusChantDesHeros += chantDesHerosIntense;
attBonus += bonusChantDesHeros;
explications.push("Chant des héros => +" + bonusChantDesHeros + " en Attaque");
if (chantDesHerosIntense)
removeTokenAttr(personnage, 'chantDesHerosTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'benediction')) {
var bonusBenediction = getValeurOfEffet(personnage, 'benediction', 1);
var benedictionIntense = attributeAsInt(personnage, 'benedictionTempeteDeManaIntense', 0);
bonusBenediction += benedictionIntense;
attBonus += bonusBenediction;
explications.push("Bénédiction => +" + bonusBenediction + " en Attaque");
if (benedictionIntense)
removeTokenAttr(personnage, 'benedictionTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'lameDeLigneePerdue')) {
attBonus -= 1;
explications.push("Lame de lignée perdue => -1 en Attaque");
}
if (attributeAsBool(personnage, 'strangulation')) {
var malusStrangulation =
1 + attributeAsInt(personnage, 'dureeStrangulation', 0);
attBonus -= malusStrangulation;
explications.push("L'attaquant est étranglé => -" + malusStrangulation + " en Attaque");
}
if (getState(personnage, 'renverse')) {
attBonus -= 5;
explications.push("Attaquant à terre => -5 en Attaque");
}
var attrPosture = tokenAttribute(personnage, 'postureDeCombat');
if (attrPosture.length > 0) {
attrPosture = attrPosture[0];
var posture = attrPosture.get('max');
var postureVal;
if (posture.startsWith('ATT')) {
postureVal = parseInt(attrPosture.get('current'));
attBonus -= postureVal;
explications.push("Posture de combat => -" + postureVal + " en Attaque");
} else if (posture.endsWith('ATT')) {
postureVal = parseInt(attrPosture.get('current'));
attBonus += postureVal;
explications.push("Posture de combat => +" + postureVal + " en Attaque");
}
}
if (attributeAsBool(personnage, 'danseIrresistible')) {
attBonus -= 4;
explications.push("En train de danser => -4 en Attaque");
}
if (attributeAsBool(personnage, 'cadavreAnime')) {
attBonus -= 4;
explications.push("Cadavre animé => -2 en Attaque");
}
if (aUnCapitaine(personnage, evt)) {
attBonus += 2;
explications.push("Un capitaine donne des ordres => +2 en Attaque");
}
if (attributeAsBool(personnage, 'forceDeGeant')) {
var bonusForceDeGeant = getValeurOfEffet(personnage, 'forceDeGeant', 2);
attBonus += bonusForceDeGeant;
explications.push("Force de géant => +" + bonusForceDeGeant + " en Attaque");
}
if (attributeAsBool(personnage, 'nueeDInsectes')) {
var malusNuee = 2 + attributeAsInt(personnage, 'nueeDInsectesTempeteDeManaIntense', 0);
attBonus -= malusNuee;
explications.push("Nuée d’insectes => -" + malusNuee + " en Attaque");
if (malusNuee > 2)
removeTokenAttr(personnage, 'nueeDInsectesTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'etatExsangue')) {
attBonus -= 2;
explications.push("Exsangue => -2 en Attaque");
}
if (attributeAsBool(personnage, 'armeBrulante')) {
attBonus -= 2;
explications.push("Arme brûlante => -2 en Attaque");
}
if (attributeAsBool(personnage, 'marcheSylvestre')) {
attBonus += 2;
explications.push("Marche sylvestre : +2 en Attaque");
}
if (attributeAsBool(personnage, 'prisonVegetale')) {
attBonus -= getValeurOfEffet(personnage, 'prisonVegetale', 2);
explications.push("Prison végétale : -2 en Attaque");
}
if (attributeAsBool(personnage, 'masqueDuPredateur')) {
var bonusMasque = getValeurOfEffet(personnage, 'masqueDuPredateur', modCarac(personnage, 'SAGESSE'));
var masqueIntense = attributeAsInt(personnage, 'masqueDuPredateurTempeteDeManaIntense', 0);
bonusMasque += masqueIntense;
attBonus += bonusMasque;
explications.push("Masque du prédateur : +" + bonusMasque + " en Attaque et DM");
if (masqueIntense)
removeTokenAttr(personnage, 'masqueDuPredateurTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'armeSecreteBarde')) {
attBonus -= 10;
explications.push("Déstabilisé par une action de charme => -10 en Attaque");
}
return attBonus;
}
function rollNumber(s) {
return parseInt(s.substring(3, s.indexOf(']')));
}
function getWeaponStats(perso, attackLabel) {
var att = getAttack(attackLabel, perso);
if (att === undefined) return;
var attPrefix = att.attackPrefix;
var weaponStats = {
name: att.weaponName
};
var charId = perso.charId;
weaponStats.attSkill = getAttrByName(charId, attPrefix + "armeatk");
weaponStats.attNbDices = getAttrByName(charId, attPrefix + "armedmnbde") || 1;
weaponStats.attDice = getAttrByName(charId, attPrefix + "armedmde") || 4;
weaponStats.crit = getAttrByName(charId, attPrefix + "armecrit") || 20;
weaponStats.divers = getAttrByName(charId, attPrefix + "armespec");
if (perso.pnj) {
if (weaponStats.attSkill === undefined) weaponStats.attSkill = 0;
weaponStats.attDMBonusCommun = getAttrByName(charId, attPrefix + "armedm");
} else {
if (!weaponStats.attSkill)
weaponStats.attSkill = "@{ATKCAC}";
weaponStats.attSkillDiv = getAttrByName(charId, attPrefix + "armeatkdiv") || 0;
weaponStats.attCarBonus =
getAttrByName(charId, attPrefix + "armedmcar") ||
modCarac(perso, "FORCE");
weaponStats.attDMBonusCommun = getAttrByName(charId, attPrefix + "armedmdiv");
}
weaponStats.portee = getPortee(charId, attPrefix);
//On cherche si c'est une arme à 2 mains
var t = weaponStats.name.toLowerCase();
if (t.includes('2 mains') || t.includes('deux mains')) {
weaponStats.deuxMains = true;
} else {
t = weaponStats.divers;
if (t) {
t = t.toLowerCase();
if (t.includes('2 mains') || t.includes('deux mains')) {
weaponStats.deuxMains = true;
}
}
}
//On cherche si c'est un arc
var p = weaponStats.name.search(/\barc\b/i);
if (p >= 0) weaponStats.arc = true;
else if (weaponStats.divers) {
p = weaponStats.divers.search(/\barc\b/i);
if (p >= 0) weaponStats.arc = true;
}
p = weaponStats.name.search(/\barbal([eè])te\b/i);
if (p >= 0) weaponStats.arbalete = true;
else if (weaponStats.divers) {
p = weaponStats.divers.search(/\barbal([eè])te\b/i);
if (p >= 0) weaponStats.arbalete = true;
}
return weaponStats;
}
function surveillance(personnage) {
var surveillance = findObjs({
_type: 'attribute',
_characterid: personnage.charId,
name: 'surveillance'
});
if (surveillance.length > 0) {
var compagnon = surveillance[0].get('current');
var compToken = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: personnage.token.get('pageid'),
layer: 'objects',
name: compagnon
});
var compagnonPresent = false;
compToken.forEach(function(tok) {
var compCharId = tok.get('represents');
if (compCharId === '') return;
if (isActive({
token: tok,
charId: compCharId
})) compagnonPresent = true;
});
return compagnonPresent;
}
return false;
}
function familier(personnage) {
var familier = findObjs({
_type: 'attribute',
_characterid: personnage.charId,
name: 'familier'
});
if (familier.length > 0) {
var compagnon = familier[0].get('current');
var compToken = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: personnage.token.get('pageid'),
layer: 'objects',
name: compagnon
});
var compagnonPresent = false;
compToken.forEach(function(tok) {
var compCharId = tok.get('represents');
if (compCharId === '') return;
if (isActive({
token: tok,
charId: compCharId
})) compagnonPresent = true;
});
return compagnonPresent;
}
return false;
}
function defenseOfToken(attaquant, target, pageId, evt, options) {
options = options || {};
if (options.difficultePVmax) {
var pvmax = parseInt(target.token.get("bar1_max"));
if (isNaN(pvmax)) {
error("Points de vie de " + target.token.get('name') + " mal formés",
target.token.get("bar1_max"));
return 0;
}
return pvmax;
}
target.tokName = target.tokName || target.token.get('name');
var tokenName = target.tokName;
var explications = target.messages || [];
var defense = 10;
if (getAttrByName(target.charId, 'type_personnage') == 'PNJ') {
defense = ficheAttributeAsInt(target, 'pnj_def', 10);
} else {
if (target.defautCuirasse === undefined) {
defense += ficheAttributeAsInt(target, 'DEFARMURE', 0) * ficheAttributeAsInt(target, 'DEFARMUREON', 1);
defense += ficheAttributeAsInt(target, 'DEFBOUCLIER', 0) * ficheAttributeAsInt(target, 'DEFBOUCLIERON', 1);
if (attributeAsBool(target, 'armureDuMage')) {
var bonusArmureDuMage = getValeurOfEffet(target, 'armureDuMage', 4);
if (defense > 12) defense += bonusArmureDuMage / 2; // On a déjà une armure physique, ça ne se cumule pas.
else defense += bonusArmureDuMage;
}
defense += ficheAttributeAsInt(target, 'DEFDIV', 0);
} // Dans le cas contraire, on n'utilise pas ces bonus
defense += modCarac(target, 'DEXTERITE');
}
var formeDarbre;
if (attributeAsBool(target, 'formeDArbre')) {
formeDarbre = true;
defense = 13;
}
if (attributeAsBool(target, 'statueDeBois')) defense = 10;
// Malus de défense global pour les longs combats
if (stateCOF.options.regles.val.usure_DEF.val)
defense -= (Math.floor((stateCOF.tour - 1) / stateCOF.options.regles.val.usure_DEF.val) * 2);
// Autres modificateurs de défense
defense += attributeAsInt(target, 'defenseTotale', 0);
defense += attributeAsInt(target, 'pacifisme', 0);
if (attributeAsBool(target, 'aspectDuDemon')) {
defense += getValeurOfEffet(target, 'aspectDuDemon', 2);
}
if (attributeAsBool(target, 'peauDEcorce')) {
var bonusPeau = getValeurOfEffet(target, 'peauDEcorce', 1, 'voieDesVegetaux');
var peauIntense = attributeAsInt(target, 'peauDEcorceTempeteDeManaIntense', 0);
bonusPeau += peauIntense;
if (stateCOF.options.regles.val.forme_d_arbre_amelioree.val && formeDarbre) {
bonusPeau = Math.ceil(bonusPeau * 1.5);
}
defense += bonusPeau;
explications.push("Peau d'écorce : +" + bonusPeau + " en DEF");
if (peauIntense && !options.test)
removeTokenAttr(target, 'peauDEcorceTempeteDeManaIntense', evt);
}
if (attributeAsBool(target, 'champDeProtection')) {
var bonusChamp = getValeurOfEffet(target, 'champDeProtection', 2, 'voieDeleTelekinesie');
var champIntense = attributeAsInt(target, 'champDeProtectionTempeteDeManaIntense', 0);
bonusChamp += champIntense;
defense += bonusChamp;
explications.push("Champ de protection : +" + bonusChamp + " en DEF");
if (champIntense && !options.test)
removeTokenAttr(target, 'champDeProtectionTempeteDeManaIntense', evt);
}
if (attributeAsBool(target, 'mutationCuirasse')) {
var bonusMutation = getValeurOfEffet(target, 'mutationCuirasse', 2, 'voieDesMutations');
defense += bonusMutation;
explications.push("Cuirasse : +" + bonusMutation + " en DEF");
}
if (attributeAsBool(target, 'sixiemeSens')) {
defense += 2;
explications.push("Sixième sens : +2 DEF");
}
if (getState(target, 'surpris')) defense -= 5;
if (getState(target, 'renverse')) defense -= 5;
if (getState(target, 'aveugle') || attributeAsBool(target, 'aveugleManoeuvre')) {
if (options.distance || !charAttributeAsBool(target, 'radarMental') || (attaquant && estNonVivant(attaquant)))
defense -= 5;
}
if (getState(target, 'etourdi') || attributeAsBool(target, 'peurEtourdi'))
defense -= 5;
defense += attributeAsInt(target, 'bufDEF', 0);
defense += attributeAsInt(target, 'actionConcertee', 0);
if (ficheAttributeAsInt(target, 'DEFARMUREON', 1) === 0) {
defense += charAttributeAsInt(target, 'vetementsSacres', 0);
defense += charAttributeAsInt(target, 'armureDeVent', 0);
if (!options.distance)
defense += charAttributeAsInt(target, 'dentellesEtRapiere', 0);
}
if (charAttributeAsBool(target, 'graceFeline')) {
defense += modCarac(target, 'CHARISME');
}
if (charAttributeAsBool(target, 'peauDePierre')) {
defense += modCarac(target, 'CONSTITUTION');
}
if (charAttributeAsBool(target, 'defenseIntuitive')) {
defense += modCarac(target, 'SAGESSE');
}
if (attributeAsBool(target, 'armeSecreteBarde')) {
defense -= 10;
}
if (options.metal && attributeAsBool(target, 'magnetisme')) {
defense += 5;
explications.push(tokenName + " contrôle le magnétisme (+5 DEF)");
}
if (attributeAsBool(target, 'diversionManoeuvre')) {
var diversion = getValeurOfEffet(target, 'diversionManoeuvre', -5);
defense += diversion;
explications.push(tokenName + " est victime d'une diversion => " + diversion + " DEF");
}
if (options.attaqueMentale && charAttributeAsBool(target, 'bouclierPsi')) {
defense += 5;
explications.push(tokenName + " bénéficie d'un bouclier psi => +5 DEF");
}
if (attributeAsBool(target, 'monteSur') && charAttributeAsBool(target, 'montureLoyale')) {
defense += 1;
explications.push(tokenName + " est sur une monture => +1 DEF");
}
var attrsProtegePar = findObjs({
_type: 'attribute',
_characterid: target.charId,
});
attrsProtegePar.forEach(function(attr) {
var attrName = attr.get('name');
if (attrName.startsWith('protegePar_')) {
var nameProtecteur = attr.get('max');
if (attr.get('bar1_link') === '') {
if (attrName != 'protegePar_' + nameProtecteur + '_' + tokenName) return;
} else if (attrName != 'protegePar_' + nameProtecteur) return;
var protecteur = tokenOfId(attr.get('current'), nameProtecteur, pageId);
if (protecteur === undefined) {
if (evt) removeTokenAttr(target, 'protegePar_' + nameProtecteur, evt);
sendChar(target.charId, "ne peut pas être protégé par " + nameProtecteur + " car aucun token le représentant n'est sur la page");
return;
}
if (!isActive(protecteur)) {
explications.push(nameProtecteur + " n'est pas en état de protéger " +
tokenName);
return;
}
var distTargetProtecteur = distanceCombat(target.token, protecteur.token, pageId);
if (distTargetProtecteur > 0) {
explications.push(nameProtecteur + " est trop loin de " +
tokenName + " pour le protéger");
return;
}
if (ficheAttributeAsInt(protecteur, 'DEFBOUCLIERON', 1) === 0) {
var sujet = onGenre(protecteur.charId, 'il', 'elle');
explications.push(nameProtecteur +
" ne porte pas son bouclier, " + sujet + " ne peut pas proteger " +
tokenName);
return;
}
var defBouclierProtecteur = ficheAttributeAsInt(protecteur, 'DEFBOUCLIER', 0);
defense += defBouclierProtecteur;
explications.push(nameProtecteur + " protège " +
tokenName + " de son bouclier (+" + defBouclierProtecteur + "DEF)");
}
});
var attrPosture = tokenAttribute(target, 'postureDeCombat');
if (attrPosture.length > 0) {
attrPosture = attrPosture[0];
var posture = attrPosture.get('max');
var postureVal;
if (posture.startsWith('DEF')) {
postureVal = parseInt(attrPosture.get('current'));
defense -= postureVal;
explications.push("Posture de combat => -" + postureVal + " DEF");
} else if (posture.endsWith('DEF')) {
postureVal = parseInt(attrPosture.get('current'));
defense += postureVal;
explications.push("Posture de combat => +" + postureVal + " DEF");
}
}
var instinctSurvie = charAttributeAsInt(target, 'instinctDeSurvie', 0);
if (instinctSurvie > 0 && target.token.get('bar1_value') <= instinctSurvie)
defense += 5;
if (attributeAsBool(target, 'danseIrresistible')) {
defense -= 4;
explications.push("En train de danser => -4 DEF");
}
if (options.sortilege)
defense += charAttributeAsInt(target, 'DEF_magie', 0);
if (attributeAsBool(target, 'marcheSylvestre')) {
defense += 2;
explications.push("Marche sylvestre => +2 DEF");
}
if (attributeAsBool(target, 'prisonVegetale')) {
defense -= getValeurOfEffet(target, 'prisonVegetale', 2);
explications.push("Prison végétale => -2 DEF");
}
if (attributeAsBool(target, 'protectionContreLeMal') &&
(attaquant && estMauvais(attaquant))) {
var bonusProtectionContreLeMal = getValeurOfEffet(target, 'protectionContreLeMal', 2);
defense += bonusProtectionContreLeMal;
explications.push("Protection contre le mal => +" + bonusProtectionContreLeMal + " DEF");
}
var rageBerserk = tokenAttribute(target, 'rageDuBerserk');
if (rageBerserk.length > 0) {
rageBerserk = rageBerserk[0].get('current');
if (rageBerserk == 'furie') {
defense -= 6;
explications.push("Furie du berserk => -6 DEF");
} else {
defense -= 4;
explications.push("Rage du berserk => -4 DEF");
}
}
var combatEnPhalange = charAttributeAsBool(target, 'combatEnPhalange');
if (combatEnPhalange || attributeAsBool(target, 'esquiveFatale')) {
var tokensContact = findObjs({
_type: 'graphic',
_subtype: "token",
_pageid: pageId,
layer: 'objects'
});
tokensContact = tokensContact.filter(function(tok) {
if (tok.id == target.token.id) return false;
return distanceCombat(target.token, tok, pageId) === 0;
});
var tokensAllies = [];
var tokensEnnemis = [];
var allies = alliesParPerso[target.charId] || new Set();
tokensContact.forEach(function(tok) {
var ci = tok.get('represents');
if (ci === '') return; //next token au contact
if (!isActive({
token: tok,
charId: ci
})) return;
if (allies.has(ci)) tokensAllies.push(tok);
else tokensEnnemis.push(tok);
});
target.ennemisAuContact = tokensEnnemis;
if (combatEnPhalange) {
var defensePhalange = 0;
tokensEnnemis.forEach(function(tokE) {
var alliesAuContact = tokensAllies.filter(function(tokA) {
return distanceCombat(tokE, tokA, pageId) === 0;
});
if (alliesAuContact.length > defensePhalange)
defensePhalange = alliesAuContact.length;
});
if (defensePhalange > 0) {
defense += defensePhalange;
explications.push("Combat en phalange => +" + defensePhalange + " DEF");
}
}
}
if (attributeAsBool(target, 'attaqueRisquee')) {
defense -= 4;
explications.push("Suite à une attaque risquée, -4 en DEF");
}
return defense;
}
//Bonus en Attaque qui ne dépendent pas du défenseur
//attaquant doit avoir un champ tokName
function bonusAttaqueA(attaquant, weaponName, evt, explications, options) {
var attBonus = 0;
if (options.bonusAttaque) attBonus += options.bonusAttaque;
attBonus += bonusDAttaque(attaquant, explications, evt);
if (options.tirDouble) {
attBonus += 2;
if (options.tirDouble.stats && options.tirDouble.stats.name) {
explications.push(attaquant.tokName + " tire avec " +
weaponName + " et " + options.tirDouble.stats.name + " à la fois !");
} else {
explications.push(attaquant.tokName + " tire avec 2 " +
weaponName + "s à la fois !");
}
}
if (options.chance) {
attBonus += options.chance;
var pc = options.chance / 10;
explications.push(pc + " point" + ((pc > 1) ? "s" : "") + " de chance dépensé => +" + options.chance + " en Attaque");
}
if (options.semonce) {
attBonus += 5;
}
if (options.attaqueAssuree) {
attBonus += 5;
explications.push("Attaque assurée => +5 en Attaque et DM/2");
}
if (attributeAsBool(attaquant, 'criDuPredateur')) {
attBonus += 1;
explications.push("Cri du prédateur => +1 en attaque");
}
if (attributeAsBool(attaquant, 'baroudHonneurActif')) {
attBonus += 5;
explications.push(attaquant.tokName + " porte une dernière attaque et s'effondre");
mort(attaquant, function(m) {
explications.push(m);
}, evt);
removeTokenAttr(attaquant, 'baroudHonneurActif', evt);
}
if (options.sortilege && attributeAsBool(attaquant, 'zoneDeSilence')) {
attBonus -= 2;
explications.push("Zone de silence => -2 en Attaque Magique");
}
if (attributeAsBool(attaquant, 'monteSur')) {
if (!options.distance) {
var cavalierEm = charAttributeAsInt(attaquant, 'cavalierEmerite');
if (cavalierEm) {
attBonus += cavalierEm;
explications.push("Cavalier émérite => +2 en Attaque");
}
}
if (charAttributeAsBool(attaquant, 'montureLoyale')) {
attBonus += 1;
explications.push("Monture loyale => +1 en Attaque");
}
}
if (options.frappeDuVide) {
attBonus += 2;
explications.push("Frappe du vide => +2 en Attaque et +1d6 DM");
}
if (attributeAsBool(attaquant, 'putrefactionOutreTombe')) {
attBonus -= 2;
explications.push("Putréfaction => -2 en Attaque");
}
if (options.contact) {
if (attributeAsBool(attaquant, 'rayonAffaiblissant')) {
options.rayonAffaiblissant = true;
attBonus -= 2;
explications.push("Rayon affaiblissant => -2 en Attaque et aux DM");
}
if (attributeAsBool(attaquant, 'enragé')) {
attBonus += 5;
explications.push("Enragé => +5 en Attaque et +1d6 DM");
}
if (attributeAsBool(attaquant, 'aspectDuDemon')) {
attBonus += getValeurOfEffet(attaquant, 'aspectDuDemon', 2);
explications.push("Aspect de démon => +2 en Attaque");
}
var rageBerserk = tokenAttribute(attaquant, 'rageDuBerserk');
if (rageBerserk.length > 0) {
rageBerserk = rageBerserk[0].get('current');
if (rageBerserk == 'furie') {
attBonus += 3;
explications.push("Furie du berserk : +3 en Attaque et +2d6 aux DM");
options.rageBerserk = 2;
} else {
attBonus += 2;
explications.push("Rage du berserk : +2 en Attaque et +1d6 aux DM");
options.rageBerserk = 1;
}
}
if (options.attaqueRisquee) {
attBonus += 2;
explications.push("Attaque risquée => +2 en Attaque");
if (!options.test)
setTokenAttr(attaquant, 'attaqueRisquee', 1, evt, undefined, getInit());
}
}
var frenesie = charAttributeAsInt(attaquant, 'frenesie', 0);
if (frenesie > 0) {
var pv = parseInt(attaquant.token.get('bar1_value'));
if (pv <= frenesie) {
attBonus += 2;
explications.push("Frénésie => +2 en Attaque");
}
}
if (options.lamesJumelles) {
var force = modCarac(attaquant, 'FORCE');
if (force < 2) {
attBonus += force - 2;
explications.push("Lames jumelles => " + (force - 2) + " en Attaque");
}
}
return attBonus;
}
//Bonus d'attaque qui dépendent de la cible
// si options.aoe, target doit avoir un champ tokName
function bonusAttaqueD(attaquant, target, portee, pageId, evt, explications, options) {
var attackingCharId = attaquant.charId;
attaquant.tokName = attaquant.tokName || attaquant.token.get('name');
var attackerTokName = attaquant.tokName;
var attBonus = 0;
if (target.bonusAttaque) attBonus += target.bonusAttaque;
if (getState(attaquant, 'aveugle')) {
if (options.distance) {
if (charAttributeAsBool(attaquant, 'tirAveugle')) {
explications.push("Attaquant aveuglé, mais il sait tirer à l'aveugle");
} else {
attBonus -= 10;
explications.push("Attaquant aveuglé => -10 en Attaque à distance");
}
} else {
if (!charAttributeAsBool(attaquant, 'radarMental') || estNonVivant(target)) {
attBonus -= 5;
explications.push("Attaquant aveuglé => -5 en Attaque");
}
}
} else if (attributeAsBool(attaquant, 'aveugleManoeuvre')) {
if (options.distance || !charAttributeAsBool(attaquant, 'radarMental') || estNonVivant(target)) {
attBonus -= 5;
options.aveugleManoeuvre = true;
explications.push("Attaquant aveuglé => -5 en Attaque et aux DM");
}
}
if (options.mainsDEnergie) {
if (options.aoe) error("Mains d'énergie n'est pas compatible avec les AOE", options.aoe);
// Check if target wears armor
var targetArmorDef = parseInt(getAttrByName(target.charId, "DEFARMURE"));
if (isNaN(targetArmorDef) || targetArmorDef === 0) {
attBonus += 2;
explications.push("Mains d'énergie => +2 en Attaque (cible sans armure)");
} else {
var bonusMain = Math.min(5, 2 + targetArmorDef);
attBonus += bonusMain;
explications.push("Mains d'énergie => +" + bonusMain + " en Attaque");
}
}
if (options.aoe === undefined && options.auto === undefined && portee > 0) {
attBonus -=
malusDistance(attaquant, target.token, target.distance, portee, pageId,
explications, options.ignoreObstacles);
}
var chasseurEmerite =
charAttributeAsBool(attaquant, 'chasseurEmerite') && estAnimal(target);
if (chasseurEmerite) {
attBonus += 2;
var explChasseurEmerite = "Chasseur émérite => +2 en Attaque et aux DM";
if (options.aoe) explChasseurEmerite += " contre " + target.tokName;
explications.push(explChasseurEmerite);
target.chasseurEmerite = true;
}
var ennemiJure = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: 'ennemiJure'
});
if (ennemiJure.length === 0) ennemiJure = false;
else ennemiJure = raceIs(target, ennemiJure[0].get('current'));
if (ennemiJure) {
var ejSag = modCarac(attaquant, 'SAGESSE');
attBonus += ejSag;
var explEnnemiJure = "Attaque sur ennemi juré => +" + ejSag + " en attaque et +1d6 aux DM";
if (options.aoe) explEnnemiJure += " contre " + target.tokName;
explications.push(explEnnemiJure);
target.ennemiJure = true;
}
if (options.armeDArgent) {
if (estMortVivant(target) || raceIs(target, 'demon') || raceIs(target, 'démon')) {
attBonus += 2;
explications.push("Arme en argent => +2 en attaque et +1d6 aux DM");
target.armeDArgent = true;
}
}
var bonusContreBouclier = options.bonusContreBouclier || 0;
if (target.bonusContreBouclier) bonusContreBouclier += target.bonusContreBouclier;
if (bonusContreBouclier) {
if (ficheAttributeAsInt(target, 'DEFBOUCLIERON', 1) &&
ficheAttributeAsInt(target, 'DEFBOUCLIER', 0) > 0) {
attBonus += bonusContreBouclier;
explications.push("L'adversaire porte un bouclier => " + ((bonusContreBouclier > 0) ? '+' : '') + bonusContreBouclier + " en attaque");
}
}
if (options.tueurDeGeants && estUnGeant(target)) {
attBonus += 2;
explications.push("Tueur de géant => +2 att. et 2d6 DM");
target.tueurDeGeants = true;
}
if (attributeAsBool(target, 'feinte_' + attaquant.tokName)) {
attBonus += 5;
explications.push("Feinte => +5 en attaque et +2d6 DM");
}
if (options.contact) {
if ((attributeAsBool(target, 'criDeGuerre') ||
attributeAsBool(target, 'criDuPredateur')) &&
ficheAttributeAsInt(attaquant, 'FORCE', 10) <= ficheAttributeAsInt(target, 'FORCE', 10) &&
parseInt(attaquant.token.get("bar1_max")) <= parseInt(target.token.get("bar1_max"))) {
attBonus -= 2;
explications.push("Effrayé => -2 en Attaque");
}
}
var attrAgrippe = tokenAttribute(attaquant, 'agrippe');
attrAgrippe.forEach(function(a) {
var cibleAgrippee = tokenOfIdName(a.get('current'), pageId);
if (cibleAgrippee && cibleAgrippee.id == target.id) {
attBonus += 5;
explications.push("Cible agrippée => +5 att. et 1d6 DM");
target.estAgrippee = true;
}
});
if (stateCOF.options.regles.val.interchangeable_attaque.val) {
if (interchangeable(target.token, attaquant, pageId).result) {
attBonus += 3;
explications.push("Attaque en meute => +3 en Attaque et +2 en DEF");
}
}
if (charAttributeAsBool(attaquant, 'combatEnPhalange')) {
var tokensContact = findObjs({
_type: 'graphic',
_subtype: "token",
_pageid: pageId,
layer: 'objects'
});
//On compte tokens au contact de l'attaquant et du défenseur et alliés de l'attaquant
var allies = alliesParPerso[attaquant.charId];
if (allies) {
var alliesAuContact = 0;
tokensContact.forEach(function(tok) {
if (tok.id == attaquant.token.id) return;
if (distanceCombat(target.token, tok, pageId) > 0) return;
if (distanceCombat(attaquant.token, tok, pageId) > 0) return;
var ci = tok.get('represents');
if (ci === '') return;
if (!isActive({
token: tok,
charId: ci
})) return;
if (allies.has(ci)) alliesAuContact++;
});
if (alliesAuContact > 0) {
attBonus += alliesAuContact;
explications.push("Combat en phalange => +" + alliesAuContact + " en Attaque");
}
}
}
var attaqueEnMeute = charAttributeAsInt(attaquant, 'attaqueEnMeute', 0);
if (attaqueEnMeute > 0) {
if (attributeAsBool(target, 'attaqueParMeute')) {
attBonus += attaqueEnMeute;
explications.push("Attaque en meute => +" + attaqueEnMeute + " pour toucher");
} else {
setTokenAttr(target, 'attaqueParMeute', true, evt);
}
}
return attBonus;
}
function computeDice(lanceur, options) {
options = options || {};
var nbDe = options.nbDe;
if (nbDe === undefined) nbDe = 1;
var plusFort = options.plusFort;
if (plusFort === undefined) plusFort = true;
var dice = options.dice;
if (dice === undefined) dice = deTest(lanceur, options.carac);
if (attributeAsBool(lanceur, 'malediction')) {
if (plusFort) {
if (nbDe > 1) nbDe--;
else {
nbDe = 2;
plusFort = false;
}
} else nbDe++;
}
var de = nbDe + "d" + dice;
if (nbDe > 1) {
if (plusFort) de += "kh1";
else de += "kl1";
}
return de;
}
function diminueMalediction(lanceur, evt, attr) {
var attrMalediction = attr || tokenAttribute(lanceur, 'malediction');
if (attrMalediction.length > 0) {
attrMalediction = attrMalediction[0];
var nbMaudit = parseInt(attrMalediction.get('current'));
if (isNaN(nbMaudit) || nbMaudit < 2) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attrMalediction);
attrMalediction.remove();
} else {
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attrMalediction,
current: nbMaudit
});
attrMalediction.set('current', nbMaudit - 1);
}
}
}
function attributesOfClass(perso, classeEffet) {
var attrs = findObjs({
_type: 'attribute',
_characterid: perso.charId
});
var res = [];
attrs.forEach(function(attr) {
var attrName = attr.get('name');
var ice = attrName.indexOf('ClasseEffet');
if (ice < 1) return;
if (attr.get('current') == classeEffet) {
var baseAttrName = attrName.replace(/ClasseEffet/, '');
var baseAttr = attrs.find(function(a) {
return (a.get('name') == baseAttrName);
});
if (baseAttr === undefined) {
error("On a un attribut " + attrName + ", mais pas d'attribut " + baseAttrName + " pour " + perso.token.get('name'), classeEffet);
attr.remove();
return;
}
res.push({
baseAttribute: baseAttr,
classAttribute: attr
});
}
});
if (res.length === 0) {
var ace = tokenAttribute(perso, classeEffet);
if (ace.length > 0) {
error(perso.token.get('name') + " a une classe d'effets " + classeEffet + " mais pas d'effet associé", ace);
ace[0].remove();
}
}
return res;
}
//Retourne true si il existe une limite qui empêche de lancer le sort
function limiteRessources(personnage, options, defResource, msg, evt) {
if (options.mana) {
if (personnage) {
if (!depenseMana(personnage, options.mana, msg, evt)) {
addEvent(evt);
return true;
}
} else {
error("Impossible de savoir qui doit dépenser de la mana", options);
return true;
}
}
var ressource = defResource;
var utilisations;
if (options.limiteParJour) {
if (personnage) {
if (options.limiteParJourRessource)
ressource = options.limiteParJourRessource;
ressource = "limiteParJour_" + ressource;
utilisations =
attributeAsInt(personnage, ressource, options.limiteParJour);
if (utilisations === 0) {
sendChar(personnage.charId, "ne peut plus faire cette action aujourd'hui");
addEvent(evt);
return true;
}
setTokenAttr(personnage, ressource, utilisations - 1, evt);
} else {
error("Impossible de à qui appliquer la limite journalière", options);
return true;
}
}
if (options.limiteParCombat) {
if (personnage) {
if (!stateCOF.combat) {
sendChar(personnage.charId, "ne peut pas faire cette action en dehors des combats");
addEvent(evt);
return true;
}
if (options.limiteParCombatRessource)
ressource = options.limiteParCombatRessource;
ressource = "limiteParCombat_" + ressource;
utilisations =
attributeAsInt(personnage, ressource, options.limiteParCombat);
if (utilisations === 0) {
sendChar(personnage.charId, "ne peut plus faire cette action pour ce combat");
addEvent(evt);
return true;
}
setTokenAttr(personnage, ressource, utilisations - 1, evt);
} else {
error("Impossible de savoir à qui appliquer la limite par combat", options);
return true;
}
}
if (options.dose) {
if (personnage) {
var nomDose = options.dose.replace(/_/g, ' ');
var doses = attributeAsInt(personnage, 'dose_' + options.dose, 0);
if (doses === 0) {
sendChar(personnage.charId, "n'a plus de " + nomDose);
addEvent(evt);
return true;
}
setTokenAttr(personnage, 'dose_' + options.dose, doses - 1, evt);
} else {
error("Impossible de savoir qui doit dépenser la dose", options);
return true;
}
}
if (options.limiteAttribut) {
if (personnage) {
var nomAttr = options.limiteAttribut.nom;
var currentAttr = attributeAsInt(personnage, nomAttr, 0);
if (currentAttr >= options.limiteAttribut.limite) {
sendChar(personnage.charId, options.limiteAttribut.message);
addEvent(evt);
return true;
}
setTokenAttr(personnage, nomAttr, currentAttr + 1, evt);
} else {
error("Impossible de savoir à qui appliquer la limitation", options);
return true;
}
}
if (options.decrAttribute) {
var attr = options.decrAttribute;
var oldval = parseInt(attr.get('current'));
if (isNaN(oldval) || oldval < 1) {
sendChar(attr.get('characterid'), "ne peut plus faire cela");
return true;
}
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attr,
current: oldval,
max: attr.get('max')
});
attr.set('current', oldval - 1);
}
return false;
}
//targetToken est soit un token, soit une structure avec un champs cibles qui contient toutes les cibles
function attack(playerId, attaquant, targetToken, attackLabel, options) {
// Attacker and target infos
var attackingToken = attaquant.token;
var attackingCharId = attaquant.charId;
attaquant.tokName = attaquant.tokName || attaquant.token.get("name");
var attacker = getObj("character", attackingCharId);
if (attacker === undefined) {
error("Unexpected undefined 1", attacker);
return;
}
attaquant.name = attaquant.name || attacker.get("name");
var pageId = attaquant.token.get('pageid');
//Options automatically set by some attributes
if (attributeAsBool(attaquant, 'paralysieRoublard')) {
if (attributeAsBool(attaquant, 'enragé')) {
sendChar(attackingCharId, "est trop enragé pour sentir la douleur");
} else if (charAttributeAsBool(attaquant, 'proprioception')) {
sendChar(attackingCharId, "est immunisé à la douleur");
} else {
sendChar(attackingCharId, "ne peut pas attaquer car il est paralysé de douleur");
return;
}
}
if (charAttributeAsBool(attaquant, 'fauchage')) {
var seuilFauchage = 10 + modCarac(attaquant, 'FORCE');
options.etats = options.etats || [];
options.etats.push({
etat: 'renverse',
condition: {
type: 'deAttaque',
seuil: 15
},
save: {
carac: 'FOR',
carac2: 'DEX',
seuil: seuilFauchage
}
});
}
var weaponName;
var weaponStats = {};
var attaqueArray;
try {
attaqueArray = JSON.parse(attackLabel);
} catch (e) {}
if (Array.isArray(attaqueArray) && attaqueArray.length > 4 &&
attaqueArray[1].length > 1 && attaqueArray[3].length > 3) {
weaponName = attaqueArray[0].replace(/_/g, ' ');
weaponStats.attSkill = attaqueArray[1][0];
weaponStats.attSkillDiv = attaqueArray[1][1];
weaponStats.crit = attaqueArray[2];
var weaponDmg = attaqueArray[3];
weaponStats.attNbDices = weaponDmg[0];
weaponStats.attDice = weaponDmg[1];
weaponStats.attCarBonus = weaponDmg[2];
weaponStats.attDMBonusCommun = weaponDmg[3];
weaponStats.portee = attaqueArray[4];
} else {
//On trouve l'attaque correspondant au label
weaponStats = getWeaponStats(attaquant, attackLabel);
if (weaponStats === undefined) {
error("Pas d'arme de label " + attackLabel, attaquant);
return;
}
weaponName = weaponStats.name;
}
weaponStats.attSkillDiv = parseInt(weaponStats.attSkillDiv);
weaponStats.attNbDices = parseInt(weaponStats.attNbDices);
weaponStats.attDice = parseInt(weaponStats.attDice);
options.d6 = 'd6';
if (charAttributeAsBool(attaquant, 'tropPetit')) {
options.d6 = 'd4';
if (weaponStats.divers && weaponStats.divers.includes('d3')) {
weaponStats.attDice = 3;
}
}
weaponStats.attDMBonusCommun = parseInt(weaponStats.attDMBonusCommun);
weaponStats.crit = parseInt(weaponStats.crit);
var portee = weaponStats.portee;
if (options.tirDouble && options.tirDouble.label) {
var stats2 = getWeaponStats(attaquant, options.tirDouble.label);
if (stats2 === undefined) {
error("Pas d'arme de label " + options.tirDouble.label + " pour le tir double", attaquant);
return;
}
var tdSkillDiv = parseInt(stats2.attSkillDiv);
if (!isNaN(tdSkillDiv) && tdSkillDiv < weaponStats.attSkillDiv)
weaponStats.attSkillDiv = tdSkillDiv;
stats2.attDMBonusCommun = parseInt(stats2.attDMBonusCommun);
stats2.attNbDices = parseInt(stats2.attNbDices);
stats2.attDice = parseInt(stats2.attDice);
if (stats2.divers && stats2.divers.includes('d3')) stats2.attDice = 3;
options.tirDouble.stats = stats2;
}
if (portee > 0) {
options.distance = true;
if (attributeAsBool(attaquant, 'rageDuBerserk')) {
sendChar(attaquant.charId, "est en rage du berserk, il ne veut attaquer qu'au contact");
return;
}
if (options.tempeteDeManaPortee) {
portee = portee * 2;
weaponStats.portee = portee;
}
} else {
options.contact = true;
}
//Pour l'option grenaille implicite, il faut vérifier que toutes les charge de l'arme sont des charges de grenaille
var chargesArme = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: "charge_" + attackLabel
});
if (!options.grenaille && chargesArme.length > 0) {
var chargesGrenaille = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: "chargeGrenaille_" + attackLabel
});
if (chargesGrenaille.length > 0) {
var chargesTotales = parseInt(chargesArme[0].get('current'));
if (!isNaN(chargesTotales)) {
var grenailles = parseInt(chargesGrenaille[0].get('current'));
if (!isNaN(grenailles) && grenailles >= chargesTotales)
options.grenaille = true;
}
}
}
if (options.grenaille) {
portee = portee / 10;
options.aoe = options.aoe || {
type: 'cone',
angle: 90
};
weaponStats.attDice -= 2;
weaponStats.attDMBonusCommun = Math.ceil(weaponStats.attDMBonusCommun / 2);
if (weaponStats.attDice < 0) weaponStats.attDice = 0;
if (options.tirDouble && options.tirDouble.stats) {
options.tirDouble.stats.attDice -= 2;
if (options.tirDouble.stats.attDice < 0) options.tirDouble.stats.attDice = 0;
}
options.auto = true;
var effet = findObjs({
_type: 'custfx',
name: 'grenaille ' + portee
});
if (effet.length === 0) {
effet = createObj('custfx', {
name: 'grenaille ' + portee,
definition: {
"angle": -1,
"angleRandom": 45,
"duration": 8,
"emissionRate": 40,
"endColour": [130, 130, 130, 0],
"endColourRandom": [10, 10, 10, 0],
"lifeSpan": portee * 5,
"lifeSpanRandom": portee / 2,
"maxParticles": 200,
"size": 10,
"sizeRandom": 3,
"speed": 12,
"speedRandom": 3,
"startColour": [25, 25, 25, 1],
"startColourRandom": [7, 7, 7, 0.5]
}
});
} else effet = effet[0];
options.fx = options.fx || effet.id;
}
//Détermination de la (ou des) cible(s)
var nomCiblePrincipale; //Utilise pour le cas mono-cible
var cibles = [];
if (options.redo) { //Dans ce cas les cibles sont précisées dans targetToken
cibles = targetToken;
if (cibles.length === 0) {
error("Attaque sans cible", targetToken);
return;
} else if (cibles.length == 1) targetToken = cibles[0].token;
nomCiblePrincipale = cibles[0].tokName;
} else {
nomCiblePrincipale = targetToken.get('name');
if (options.aoe) {
if (options.targetFx) {
spawnFx(targetToken.get('left'), targetToken.get('top'), options.targetFx, pageId);
}
var distanceTarget = distanceCombat(targetToken, attackingToken, pageId, {
strict1: true,
strict2: true
});
var pta = tokenCenter(attackingToken);
var ptt = tokenCenter(targetToken);
switch (options.aoe.type) {
case 'ligne':
if (distanceTarget < portee) { //la ligne va plus loin que la cible
var scale = portee * 1.0 / distanceTarget;
ptt = [
Math.round((ptt[0] - pta[0]) * scale) + pta[0],
Math.round((ptt[1] - pta[1]) * scale) + pta[1]
];
}
if (targetToken.get('bar1_max') == 0) { // jshint ignore:line
//C'est juste un token utilisé pour définir la ligne
if (options.fx) {
var p1e = {
x: attackingToken.get('left'),
y: attackingToken.get('top'),
};
var p2e = {
x: targetToken.get('left'),
y: targetToken.get('top'),
};
spawnFxBetweenPoints(p1e, p2e, options.fx, pageId);
}
cibles = [];
targetToken.remove(); //On l'enlève, normalement plus besoin
}
var allToks =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
allToks.forEach(function(obj) {
if (obj.id == attackingToken.id) return; //on ne se cible pas
var objCharId = obj.get('represents');
if (objCharId === '') return;
var cible = {
token: obj,
charId: objCharId
};
if (getState(cible, 'mort')) return; //pas de dégâts aux morts
var pt = tokenCenter(obj);
var distToTrajectory = VecMath.ptSegDist(pt, pta, ptt);
if (distToTrajectory > (obj.get('width') + obj.get('height')) / 4)
return;
cible.tokName = obj.get('name');
var objChar = getObj('character', objCharId);
if (objChar === undefined) return;
cible.name = objChar.get('name');
cibles.push(cible);
});
break;
case 'disque':
if (distanceTarget > portee) {
sendChar(attackingCharId,
"Le centre du disque visé est trop loin pour " + weaponName +
" (distance " + distanceTarget + ", portée " + portee + ")");
return;
}
var allToksDisque =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
allToksDisque.forEach(function(obj) {
if (portee === 0 && obj.id == attackingToken.id) return; //on ne se cible pas si le centre de l'aoe est soi-même
if (obj.get('bar1_max') == 0) return; // jshint ignore:line
var objCharId = obj.get('represents');
if (objCharId === '') return;
var cible = {
token: obj,
charId: objCharId
};
if (getState(cible, 'mort')) return; //pas de dégâts aux morts
var distanceCentre =
distanceCombat(targetToken, obj, pageId, {
strict1: true
});
if (distanceCentre > options.aoe.rayon) return;
var objChar = getObj('character', objCharId);
if (objChar === undefined) return;
cible.name = objChar.get('name');
cible.tokName = obj.get('name');
cibles.push(cible);
});
if (targetToken.get('bar1_max') == 0) { // jshint ignore:line
//C'est juste un token utilisé pour définir le disque
targetToken.remove(); //On l'enlève, normalement plus besoin
}
// La nouvelle portée (pour ne rien éliminer à l'étape suivante
portee += options.aoe.rayon;
break;
case 'cone':
if (options.fx) {
var p1eC = {
x: attackingToken.get('left'),
y: attackingToken.get('top'),
};
var p2eC = {
x: targetToken.get('left'),
y: targetToken.get('top'),
};
spawnFxBetweenPoints(p1eC, p2eC, options.fx, pageId);
}
var vecCentre = VecMath.normalize(VecMath.vec(pta, ptt));
var cosAngle = Math.cos(options.aoe.angle * Math.PI / 360.0);
//Pour éviter des artfacts d'arrondi:
cosAngle = (Math.floor(cosAngle * 1000000)) / 1000000;
if (targetToken.get('bar1_max') == 0) { // jshint ignore:line
//C'est juste un token utilisé pour définir le cone
cibles = [];
targetToken.remove(); //On l'enlève, normalement plus besoin
}
var allToksCone =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
allToksCone.forEach(function(obj) {
if (obj.id == attackingToken.id) return; //on ne se cible pas
var objCharId = obj.get('represents');
if (objCharId === '') return;
var cible = {
token: obj,
charId: objCharId
};
if (getState(cible, 'mort')) return; //pas de dégâts aux morts
var pt = tokenCenter(obj);
var vecObj = VecMath.normalize(VecMath.vec(pta, pt));
if (VecMath.dot(vecCentre, vecObj) < cosAngle) return;
// La distance sera comparée à la portée plus loin
var objChar = getObj('character', objCharId);
if (objChar === undefined) return;
cible.name = objChar.get('name');
cible.tokName = obj.get('name');
cibles.push(cible);
});
break;
default:
error("aoe inconnue", options.aoe);
return;
}
} else {
if (attackingToken.id == targetToken.id) { //même token pour attaquant et cible
sendChar(attackingCharId,
"s'attaque " + onGenre(attackingCharId, "lui", "elle") +
"-même ? Probablement une erreur à la sélection de la cible. On annule");
return;
}
var targetCharId = targetToken.get("represents");
if (targetCharId === "") {
error("Le token ciblé (" + nomCiblePrincipale + ") doit représenter un personnage ", targetToken);
return;
}
var targetChar = getObj("character", targetCharId);
if (targetChar === undefined) {
error("Unexpected undefined 2", targetChar);
return;
}
cibles = [{
token: targetToken,
charId: targetCharId,
name: targetChar.get('name'),
tokName: nomCiblePrincipale
}];
}
if (options.ciblesSupplementaires) {
options.ciblesSupplementaires.forEach(function(c) {
var i = cibles.indexOf(function(t) {
return (t.token.id == c.token.id);
});
if (i < 0) cibles.push(c);
});
}
}
//Les conditions qui peuvent empêcher l'attaque
if (options.conditionAttaquant !== undefined) {
if (!testCondition(options.conditionAttaquant, attaquant, cibles)) {
sendChar(attackingCharId, "ne peut pas utiliser " + weaponName);
return;
}
}
if (options.avecd12 && (estAffaibli(attaquant) || getState(attaquant, 'immobilise'))) {
sendChar(attackingCharId, "ne peut pas utiliser cette capacité quand il est affaibli.");
return;
}
var attrRipostesDuTour = tokenAttribute(attaquant, 'ripostesDuTour');
var ripostesDuTour = new Set();
if (attrRipostesDuTour.length > 0) {
ripostesDuTour = new Set(attrRipostesDuTour[0].get('current').split(' '));
}
cibles = cibles.filter(function(target) {
if (attributeAsBool(target, 'ombreMortelle')) {
sendChar(attackingCharId, "impossible d'attaquer une ombre");
return false;
}
if (options.seulementVivant && estNonVivant(target)) {
sendChar(attackingCharId, "cette attaque n'affecte que les créatures vivantes");
return false;
}
if (options.pointsVitaux && estNonVivant(target)) {
sendChar(attackingCharId, "La cible n'est pas vraiment vivante : " + attaquant.name + " ne trouve pas de points vitaux");
return false;
}
if (attributeAsBool(attaquant, 'tenuADistanceManoeuvre(' + target.token.id + ')')) {
sendChar(attackingCharId, "est tenu à distance de " + target.tokName + ", " + onGenre(attackingCharId, "il", "elle") + " ne peut pas l'attaquer ce tour.");
return false;
}
if (charAttributeAsBool(target, 'armeeConjuree')) {
return options.attaqueArmeeConjuree;
}
if (ripostesDuTour.has(target.token.id)) {
sendChar(attackingCharId, "a déjà fait une riposte contre " + target.tokName);
return false;
}
return true;
});
if (cibles.length === 0) return;
//Prise en compte de la distance
var optDistance = {};
if (options.contact) optDistance.allonge = options.allonge;
// Si l'attaquant est monté, distance mesurée à partir de sa monture
var pseudoAttackingToken = attackingToken;
var attrMonture = tokenAttribute(attaquant, 'monteSur');
if (attrMonture.length > 0) {
var pseudoAttacker =
tokenOfId(attrMonture[0].get('current'), attrMonture[0].get('max'), pageId);
if (pseudoAttacker) pseudoAttackingToken = pseudoAttacker.token;
}
cibles = cibles.filter(function(target) {
// Si la cible est montée, distance mesurée vers sa monture
var pseudoTargetToken = target.token;
attrMonture = tokenAttribute(target, 'monteSur');
if (attrMonture.length > 0) {
var pseudoTarget =
tokenOfId(attrMonture[0].get('current'), attrMonture[0].get('max'), pageId);
if (pseudoTarget) pseudoTargetToken = pseudoTarget.token;
}
target.distance =
distanceCombat(pseudoAttackingToken, pseudoTargetToken, pageId, optDistance);
if (options.intercepter || options.interposer) return true;
if (target.distance > portee && target.esquiveFatale === undefined) {
if (options.aoe || options.auto) return false; //distance stricte
if (target.distance > 2 * portee) return false;
// On peut aller jusqu'à 2x portee si unique cible et jet d'attaque
return true;
}
return true;
});
//On enlève les alliés si l'option saufAllies est active
if (options.saufAllies) {
var allies = new Set();
allies = alliesParPerso[attaquant.charId] || allies;
allies = (new Set(allies)).add(attaquant.charId);
cibles = cibles.filter(function(target) {
return !(allies.has(target.charId));
});
}
if (cibles.length === 0) {
if (options.aoe) {
sendChar(attackingCharId, "aucune cible dans l'aire d'effet de " + weaponName + ", action annulée");
return;
}
sendChar(attackingCharId, "est hors de portée de " + nomCiblePrincipale + " pour une attaque utilisant " + weaponName + ", action annulée");
return;
}
var evt = options.evt || {
type: "Tentative d'attaque"
};
if (options.attaqueArmeeConjuree) {
setTokenAttr(attaquant, 'attaqueArmeeConjuree', 1, evt, undefined, getInit());
}
evt.action = evt.action || {
options: JSON.parse(JSON.stringify(options)) //pour la chance etc.
};
if (options.tempsRecharge) {
if (attributeAsBool(attaquant, options.tempsRecharge.effet)) {
sendChar(attackingCharId, "ne peut pas encore utiliser cette attaque");
return;
}
if (options.tempsRecharge.duree > 0)
setTokenAttr(attaquant, options.tempsRecharge.effet, options.tempsRecharge.duree, evt, undefined, getInit());
}
//On met à jour l'arme en main, si nécessaire
if (weaponStats.divers && weaponStats.divers.toLowerCase().includes('arme')) {
options.weaponStats = weaponStats;
options.messages = options.messages || [];
degainerArme(attaquant, attackLabel, evt, options);
}
if (charAttributeAsBool(attaquant, 'riposte')) {
//On stoque les cibles attaquées, pour ne pas les re-proposer en riposte
var listeCibles =
cibles.map(function(target) {
return target.token.id;
}).join(' ');
if (attrRipostesDuTour.length === 0) {
if (options.riposte) {
setTokenAttr(attaquant, 'ripostesDuTour', listeCibles, evt);
} else {
setTokenAttr(attaquant, 'ripostesDuTour', '', evt, undefined, listeCibles);
}
} else { //L'attribut existe déjà
attrRipostesDuTour = attrRipostesDuTour[0];
evt.attributes = evt.attributes || [];
ripostesDuTour = attrRipostesDuTour.get('current');
var attaquesDuTour = attrRipostesDuTour.get('max');
evt.attributes.push({
attribute: attrRipostesDuTour,
current: ripostesDuTour,
max: attaquesDuTour
});
if (options.riposte) {
if (ripostesDuTour === '') ripostesDuTour = listeCibles;
else ripostesDuTour += ' ' + listeCibles;
attrRipostesDuTour.set('current', ripostesDuTour);
} else {
if (attaquesDuTour === '') attaquesDuTour = listeCibles;
else attaquesDuTour += ' ' + listeCibles;
attrRipostesDuTour.set('max', attaquesDuTour);
}
}
}
//On fait les tests pour les cibles qui bénéficieraient d'un sanctuaire
var ciblesATraiter = cibles.length;
var attaqueImpossible = false;
cibles.forEach(function(cible) {
if (attaqueImpossible) return;
if (attributeAsBool(cible, 'sanctuaire')) {
testCaracteristique(attaquant, 'SAG', 15, {}, evt, function(tr) {
if (tr.reussite) {
sendChar(attaquant.charId, "réussi à passer outre le sanctuaire de " + cible.tokName + " (jet de SAG " + tr.texte + "≥15)");
ciblesATraiter--;
if (ciblesATraiter === 0)
resoudreAttaque(attaquant, cibles, attackLabel, weaponName, weaponStats, playerId, pageId, evt, options, chargesArme);
} else {
sendChar(attaquant.charId, "ne peut se résoudre à attaquer " + cible.tokName + " (sanctuaire, jet de SAG " + tr.texte + "< 15)");
attaqueImpossible = true;
}
});
} else {
ciblesATraiter--;
if (ciblesATraiter === 0)
resoudreAttaque(attaquant, cibles, attackLabel, weaponName, weaponStats, playerId, pageId, evt, options, chargesArme);
}
});
}
function displayAttaqueOpportunite(vid, cibles, type, action, option) {
var attaquant = tokenOfId(vid);
if (attaquant === undefined) {
error("Impossible de retrouver le personnage qui pouvait faire une attaque " + type, vid);
return;
}
var abilities = findObjs({
_type: 'ability',
_characterid: attaquant.charId,
});
var actions;
var actionTrouvee;
abilities.forEach(function(a) {
if (actionTrouvee) return;
var an = a.get('name');
if (an == action) {
actions = a;
actionTrouvee = true;
return;
}
if (an == '#Actions#' || an == '#TurnAction#') actions = a;
});
var actionsOpportunite = [];
if (actions) {
actions = actions.get('action').replace(/\n/gm, '').replace(/\r/gm, '').replace(/%/g, '\n%').replace(/#/g, '\n#').split("\n");
if (actions.length > 0) {
var macros = findObjs({
_type: 'macro'
});
var command = '';
actions.forEach(function(action, i) {
action = action.trim();
if (action.length > 0) {
var actionCmd = action.split(' ')[0];
var actionText = action.replace(/-/g, ' ').replace(/_/g, ' ');
if (actionCmd.startsWith('%')) {
actionCmd = actionCmd.substr(1);
actionText = actionText.substr(1);
abilities.forEach(function(abilitie, index) {
if (abilitie.get('name') === actionCmd) {
command = abilitie.get('action').trim();
command = replaceAction(command, attaquant, macros, abilities);
if (command.startsWith('!cof-attack')) {
actionsOpportunite.push({
command: command,
text: actionText
});
}
}
});
} else if (actionCmd.startsWith('#')) {
actionCmd = actionCmd.substr(1);
actionText = actionText.substr(1);
macros.forEach(function(macro, index) {
if (macro.get('name') === actionCmd) {
command = macro.get('action').trim();
command = replaceAction(command, attaquant, macros, abilities);
if (command.startsWith('!cof-attack')) {
actionsOpportunite.push({
command: command,
text: actionText
});
}
}
});
} else if (actionCmd.startsWith('!cof-attack')) {
actionsOpportunite.push({
command: actionCmd,
text: actionText
});
}
}
});
}
}
if (actionsOpportunite.length === 0) {
//Pas besoin de faire un frame, on n'a pas d'action
var ligne = "peut faire une attaque " + type + " contre";
cibles.forEach(function(target) {
ligne += ' ' + target.token.get('name');
});
sendChar(attaquant.charId, ligne);
return;
}
//On crée un display sans le header
var display = startFramedDisplay(undefined, "Attaque " + type + " possible", attaquant, {
retarde: true
});
cibles.forEach(function(target) {
target.tokName = target.tokName || target.token.get('name');
if (target.name === undefined) {
var targetChar = getObj('character', target.charId);
if (targetChar === undefined) {
error('Impossible de trouver le personnage représentant ' + target.tokName, target);
return;
}
target.name = targetChar.get('name');
}
addLineToFramedDisplay(display, "contre " + target.tokName, 100, true);
actionsOpportunite.forEach(function(action) {
var cmd = action.command.replace(/@\{target\|token_id\}/g, target.token.id);
cmd = cmd.replace(/@\{target\|token_name\}/g, target.tokName);
cmd = cmd.replace(/@\{target\|/g, '@{' + target.name + '|');
if (option) cmd += ' ' + option;
addLineToFramedDisplay(display, bouton(cmd, action.text, attaquant));
});
});
// on envoie la liste aux joueurs qui gèrent l'attaquant
var playerIds = getPlayerIds(attaquant);
playerIds.forEach(function(playerid) {
addFramedHeader(display, playerid, true);
sendChat('', endFramedDisplay(display));
});
if (playerIds.length === 0) {
addFramedHeader(display, undefined, 'gm');
sendChat('', endFramedDisplay(display));
}
}
function ajouteDe6Crit(x, first) {
var bonusCrit = rollDePlus(6);
if (first) x.dmgDisplay = "(" + x.dmgDisplay + ")";
x.dmgDisplay += '+' + bonusCrit.roll;
x.dmgTotal += bonusCrit.val;
}
// Fonction asynchrone
// displayRes est optionnel, et peut avoir 2 arguments
// - un texte affichant le jet de dégâts
// - la valeur finale des dégâts infligés
// crit est un booléen, il augmente de 1 (ou options.critCoef) le coefficient (option.dmgCoef) et active certains effets
function dealDamage(target, dmg, otherDmg, evt, crit, options, explications, displayRes) {
if (target.tokName === undefined) target.tokName = target.token.get('name');
if (options === undefined) options = {};
var expliquer = function(msg) {
if (explications) explications.push(msg);
else sendChar(target.charId, msg);
};
if (options.interposer) {
return dealDamageAfterOthers(target, crit, {}, evt, expliquer, displayRes, options.interposer, dmg.display, false);
}
if (attributeAsBool(target, 'intangible') ||
attributeAsBool(target, 'ombreMortelle') ||
(options.aoe === undefined &&
attributeAsBool(target, 'formeGazeuse'))) {
expliquer("L'attaque passe à travers de " + target.token.get('name'));
if (displayRes) displayRes('0', 0);
return 0;
}
if (options.asphyxie &&
(charAttributeAsBool(target, 'creatureArtificielle') ||
estNonVivant(target))) {
expliquer("L'asphyxie est sans effet sur une créature non-vivante");
if (displayRes) displayRes('0', 0);
return 0;
}
var dmgCoef = options.dmgCoef || 1;
if (target.dmgCoef) dmgCoef += target.dmgCoef;
var critCoef = 1;
if (crit) {
if (options.critCoef) critCoef = options.critCoef;
if (target.critCoef) critCoef += target.critCoef;
dmgCoef += critCoef;
}
otherDmg = otherDmg || [];
var dmgDisplay = dmg.display;
var dmgTotal = dmg.total;
var showTotal = false;
if (dmgCoef > 1) {
dmgDisplay += " X " + dmgCoef;
dmgTotal = dmgTotal * dmgCoef;
showTotal = true;
}
if (crit) {
if (attributeAsBool(target, 'memePasMal')) {
options.memePasMal = (dmgTotal / dmgCoef) * critCoef;
}
var firstBonusCritique = true;
var x = {
dmgDisplay: dmgDisplay,
dmgTotal: dmgTotal
};
if (options.affute) {
ajouteDe6Crit(x, firstBonusCritique);
firstBonusCritique = false;
}
if (options.tirFatal) {
ajouteDe6Crit(x, firstBonusCritique);
if (options.tirFatal > 1) {
ajouteDe6Crit(x, false);
}
}
if (options.memePasMal !== undefined) {
options.memePasMal += x.dmgTotal - dmgTotal;
}
dmgDisplay = x.dmgDisplay;
dmgTotal = x.dmgTotal;
}
//On trie les DM supplémentaires selon leur type
var dmgParType = {};
otherDmg.forEach(function(d) {
if (_.has(dmgParType, d.type)) dmgParType[d.type].push(d);
else dmgParType[d.type] = [d];
});
// Dommages de même type que le principal, mais à part, donc non affectés par les critiques
var mainDmgType = dmg.type;
var dmgExtra = dmgParType[mainDmgType];
if (dmgExtra && dmgExtra.length > 0 && !charAttributeAsBool(target, 'immunite_' + mainDmgType)) {
if (dmgCoef > 1) dmgDisplay = "(" + dmgDisplay + ")";
showTotal = true;
var count = dmgExtra.length;
dmgExtra.forEach(function(d) {
count--;
partialSave(d, target, false, d.display, d.total, expliquer, evt,
function(res) {
if (res) {
dmgTotal += res.total;
dmgDisplay += "+" + res.dmgDisplay;
} else {
dmgTotal += d.total;
dmgDisplay += "+" + d.display;
}
if (count === 0) dealDamageAfterDmgExtra(target, mainDmgType, dmgTotal, dmgDisplay, showTotal, dmgParType, dmgExtra, crit, options, evt, expliquer, displayRes);
});
});
} else {
return dealDamageAfterDmgExtra(target, mainDmgType, dmgTotal, dmgDisplay, showTotal, dmgParType, dmgExtra, crit, options, evt, expliquer, displayRes);
}
}
// Effets quand on rentre en combat
// attaquant doit avoir un tokName et peut calculer le name
function entrerEnCombat(attaquant, cibles, explications, evt) {
var selected = [{
_id: attaquant.token.id
}];
cibles.forEach(function(target) {
selected.push({
_id: target.token.id
});
});
initiative(selected, evt); //ne recalcule pas l'init
if (getState(attaquant, 'invisible')) {
explications.push(attaquant.tokName + " redevient visible");
setState(attaquant, 'invisible', false, evt);
}
var pacifisme = tokenAttribute(attaquant, 'pacifisme');
if (pacifisme.length > 0 && pacifisme[0].get('current') > 0) {
pacifisme[0].set('current', 0);
if (attaquant.name === undefined) {
var attackChar = getObj('character', attaquant.charId);
if (attackChar) attaquant.name = attackChar.get('name');
else attaquant.name = attaquant.tokName;
}
sendChat("GM", '/w "' + attaquant.name + '" ' + attaquant.tokName + " perd son pacifisme");
}
if (attributeAsBool(attaquant, 'sanctuaire')) {
explications.push(attaquant.tokName + " met fin aux conditions du sanctuaire");
removeTokenAttr(attaquant, 'sanctuaire', evt);
}
}
//L'argument weaponStats est optionnel
function critEnAttaque(attaquant, weaponStats, options) {
var crit = 20;
if (weaponStats) crit = weaponStats.crit;
if (isNaN(crit) || crit < 1 || crit > 20) {
error("Le critique n'est pas un nombre entre 1 et 20", crit);
crit = 20;
}
if (charAttributeAsBool(attaquant, 'scienceDuCritique') ||
(!options.distance && !options.sortilege && charAttributeAsBool(attaquant, 'morsureDuSerpent')) ||
(crit == 20 && charAttributeAsBool(attaquant, 'ecuyer'))) crit -= 1;
if (options.bonusCritique) crit -= options.bonusCritique;
if (options.affute) crit -= 1;
if (options.contact && charAttributeAsBool(attaquant, 'frappeChirurgicale'))
crit -= modCarac(attaquant, 'INTELLIGENCE');
var attrTirFatal = charAttribute(attaquant.charId, 'tirFatal');
if (attrTirFatal.length > 0) {
var armeTirFatal = attrTirFatal[0].get('current');
if (armeTirFatal == 'true') armeTirFatal = 'arc';
if (options[armeTirFatal] || weaponStats[armeTirFatal]) {
crit -= modCarac(attaquant, 'SAGESSE');
options.tirFatal = 1;
if (charAttributeAsInt(attaquant, 'voieDeLArcEtDuCheval', 3) > 4)
options.tirFatal = 2;
}
}
if (crit < 2) crit = 2;
return crit;
}
//attaquant doit avoir un champ name
function attackExpression(attaquant, nbDe, dice, crit, weaponStats) {
var de = computeDice(attaquant, {
nbDe: nbDe,
dice: dice
});
var attackRollExpr = "[[" + de + "cs>" + crit + "cf1]]";
var attSkillDiv = weaponStats.attSkillDiv;
if (isNaN(attSkillDiv)) attSkillDiv = 0;
var attSkillDivTxt = "";
if (attSkillDiv > 0) attSkillDivTxt = " + " + attSkillDiv;
else if (attSkillDiv < 0) attSkillDivTxt += attSkillDiv;
var attackSkillExpr = addOrigin(attaquant.name, "[[" + computeArmeAtk(attaquant, weaponStats.attSkill) + attSkillDivTxt + "]]");
return attackRollExpr + " " + attackSkillExpr;
}
function resoudreAttaque(attaquant, cibles, attackLabel, weaponName, weaponStats, playerId, pageId, evt, options, chargesArme) {
var attackingCharId = attaquant.charId;
var attackingToken = attaquant.token;
var attackerName = attaquant.name;
var attackerTokName = attaquant.tokName;
var explications = options.messages || [];
var sujetAttaquant = onGenre(attackingCharId, 'il', 'elle');
if (options.contact) {
//Pris en compte du corps élémentaire
var attrCorpsElem = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: 'corpsElementaire'
});
attrCorpsElem.forEach(function(attr) {
var typeCorpsElem = attr.get('current');
options.additionalDmg.push({
type: typeCorpsElem,
value: '1d6',
});
explications.push("Corps de " + typeCorpsElem + " => +1d6 DM");
});
}
// Munitions
if (options.munition) {
if (attackingToken.get('bar1_link') === '') {
error("Les munitions ne sont pas supportées pour les tokens qui ne sont pas liées à un personnage", attackingToken);
}
var munitionsAttr = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: 'munition_' + options.munition.nom
});
if (munitionsAttr.length === 0) {
error("Pas de munition nommée " + options.munition.nom + " pour " + attackerName);
return; //evt toujours vide
}
munitionsAttr = munitionsAttr[0];
var munitions = munitionsAttr.get('current');
if (munitions < 1 || (options.tirDouble && munitions < 2)) {
sendChar(attackingCharId,
"ne peut pas utiliser cette attaque, car " + sujetAttaquant +
" n'a plus de " + options.munition.nom.replace(/_/g, ' '));
return; //evt toujours vide
}
var munitionsMax = parseInt(munitionsAttr.get('max'));
if (isNaN(munitionsMax)) {
error("Attribut de munitions mal formé", munitionsMax);
return;
}
//À partir de ce point, tout return doit ajouter evt
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: munitionsAttr,
current: munitions,
max: munitionsMax
});
//On cherche si la munition est empoisonnée
var poisonAttr = tokenAttribute(attaquant, 'poisonRapide_munition_' + options.munition.nom);
if (poisonAttr.length > 0) {
poisonAttr = poisonAttr[0];
var infosPoisonMunitions = poisonAttr.get('max');
var infosPoisonMunitionsIndex = infosPoisonMunitions.indexOf(' ');
var seuilMunitionsEmpoisonnees = parseInt(infosPoisonMunitions.substring(0, infosPoisonMunitionsIndex));
var nombreMunitionsEmpoisonnees = parseInt(infosPoisonMunitions.substring(infosPoisonMunitionsIndex + 1));
if (!isNaN(seuilMunitionsEmpoisonnees) && !isNaN(nombreMunitionsEmpoisonnees) && nombreMunitionsEmpoisonnees > 0) {
options.additionalDmg.push({
type: 'poison',
value: poisonAttr.get('current'),
partialSave: {
carac: 'CON',
seuil: seuilMunitionsEmpoisonnees
}
});
explications.push("L'arme est empoisonnée");
if (nombreMunitionsEmpoisonnees == 1) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(poisonAttr);
poisonAttr.remove();
} else {
evt.attributes.push({
attribute: poisonAttr,
current: poisonAttr.get('current'),
max: infosPoisonMunitions
});
poisonAttr.set('max', seuilMunitionsEmpoisonnees + ' ' + (nombreMunitionsEmpoisonnees - 1));
}
}
}
munitions--;
if (randomInteger(100) < options.munition.taux) munitionsMax--;
if (options.tirDouble) {
munitions--;
if (randomInteger(100) < options.munition.taux) munitionsMax--;
}
explications.push("Il reste " + munitions + " " +
options.munition.nom.replace(/_/g, ' ') + " à " + attackerTokName);
munitionsAttr.set('current', munitions);
munitionsAttr.set('max', munitionsMax);
}
// Armes chargées
if (options.semonce === undefined && options.tirDeBarrage === undefined) {
if (chargesArme.length > 0) {
var currentCharge = parseInt(chargesArme[0].get('current'));
if (isNaN(currentCharge) || currentCharge < 1) {
sendChar(attackingCharId, "ne peut pas attaquer avec " + weaponName + " car elle n'est pas chargée");
addEvent(evt);
return;
}
if (options.tirDouble &&
(!options.tirDouble.stats || options.tirDouble.label == attackLabel) &&
currentCharge < 2) {
sendChar(attackingCharId,
"ne peut pas faire de tir double avec ses" + weaponName + "s car " +
sujetAttaquant + " n'en a pas au moins 2 chargées");
addEvent(evt);
return;
}
evt.attributes = evt.attributes || [];
if (options.grenaille) {
var chargesGrenaille = tokenAttribute(attaquant, 'chargeGrenaille_' + attackLabel);
if (chargesGrenaille.length > 0) {
var currentChargeGrenaille = parseInt(chargesGrenaille[0].get('current'));
if (isNaN(currentChargeGrenaille) || currentChargeGrenaille < 1) {
sendChar(attackingCharId, "ne peut pas attaquer avec " + weaponName + " car elle n'est pas chargée en grenaille");
addEvent(evt);
return;
}
if (options.tirDouble &&
(!options.tirDouble.stats || options.tirDouble.label == attackLabel) &&
currentChargeGrenaille < 2) {
sendChar(attackingCharId,
"ne peut pas faire de tir double de grenaille avec ses" + weaponName + "s car " +
sujetAttaquant + " n'en a pas au moins 2 chargées de grenaille");
addEvent(evt);
return;
}
evt.attributes.push({
attribute: chargesGrenaille[0],
current: currentChargeGrenaille
});
if (options.tirDouble &&
(!options.tirDouble.stats || options.tirDouble.label == attackLabel)
) currentChargeGrenaille -= 2;
else currentChargeGrenaille -= 1;
chargesGrenaille[0].set('current', currentChargeGrenaille);
}
}
evt.attributes.push({
attribute: chargesArme[0],
current: currentCharge
});
if (options.tirDouble &&
(!options.tirDouble.stats || options.tirDouble.label == attackLabel)) currentCharge -= 2;
else currentCharge -= 1;
chargesArme[0].set('current', currentCharge);
if (currentCharge === 0 &&
charAttributeAsInt(attaquant, "initEnMain" + attackLabel, 0) > 0) {
updateNextInit(attackingToken);
}
}
if (options.tirDouble && options.tirDouble.label && options.tirDouble.label != attackLabel) {
var secondLabel = options.tirDouble.label;
var secondNom = options.tirDouble.stats.name;
var chargesSecondeArme = findObjs({
_type: 'attribute',
_characterid: attackingCharId,
name: "charge_" + secondLabel
});
if (chargesSecondeArme.length > 0) {
var currentCharge2 = parseInt(chargesSecondeArme[0].get('current'));
if (isNaN(currentCharge2) || currentCharge2 < 1) {
sendChar(attackingCharId, "ne peut pas faire de tir double avec " + secondNom + " car ce n'est pas chargé");
addEvent(evt);
return;
}
evt.attributes = evt.attributes || [];
if (options.grenaille) {
var chargesGrenaille2 = tokenAttribute(attaquant, 'chargeGrenaille_' + secondLabel);
if (chargesGrenaille2.length > 0) {
var currentChargeGrenaille2 = parseInt(chargesGrenaille2[0].get('current'));
if (isNaN(currentChargeGrenaille2) || currentChargeGrenaille2 < 1) {
sendChar(attackingCharId, "ne peut pas faire de tir double avec " + secondNom + " car ce n'est pas chargé en grenaille");
addEvent(evt);
return;
}
evt.attributes.push({
attribute: chargesGrenaille2[0],
current: currentChargeGrenaille2
});
currentChargeGrenaille2 -= 1;
chargesGrenaille2[0].set('current', currentChargeGrenaille2);
}
}
evt.attributes.push({
attribute: chargesSecondeArme[0],
current: currentCharge2
});
chargesArme[0].set('current', currentCharge2 - 1);
if (currentCharge2 == 1 &&
charAttributeAsInt(attaquant, "initEnMain" + secondLabel, 0) > 0) {
updateNextInit(attackingToken);
}
}
}
}
if (limiteRessources(attaquant, options, attackLabel, weaponName, evt))
return;
// Effets quand on rentre en combat
entrerEnCombat(attaquant, cibles, explications, evt);
// On commence par le jet d'attaque de base : juste le ou les dés d'attaque
// et le modificateur d'arme et de caractéritiques qui apparaissent dans
// la description de l'attaque. Il faut quand même tenir compte des
// chances de critique
var crit = critEnAttaque(attaquant, weaponStats, options);
var dice = 20;
if (estAffaibli(attaquant)) {
dice = 12;
explications.push("Attaquant affaibli => D12 au lieu de D20 en Attaque");
} else if (getState(attaquant, 'immobilise')) {
dice = 12;
explications.push("Attaquant aimmobilisé => D12 au lieu de D20 en Attaque");
}
var ebriete = attributeAsInt(attaquant, 'niveauEbriete', 0);
if (ebriete > 0) {
if (options.distance || options.sortilege || ebriete > 1) {
dice = 12;
if (ebriete > 3) ebriete = 3;
explications.push("Attaquant " + niveauxEbriete[ebriete] + " => D12 au lieu de D20 en Attaque");
}
}
if (options.avecd12) dice = 12;
var nbDe = 1;
if (options.m2d20) nbDe = 2;
// toEvaluateAttack inlines
// 0: attack roll
// 1: attack skill expression
// 2: dé de poudre
var toEvaluateAttack = attackExpression(attaquant, nbDe, dice, crit, weaponStats);
if (options.poudre) toEvaluateAttack += " [[1d20]]";
sendChat(attackerName, toEvaluateAttack, function(resAttack) {
var rollsAttack = options.rollsAttack || resAttack[0];
var afterEvaluateAttack = rollsAttack.content.split(' ');
var attRollNumber = rollNumber(afterEvaluateAttack[0]);
var attSkillNumber = rollNumber(afterEvaluateAttack[1]);
var d20roll = rollsAttack.inlinerolls[attRollNumber].results.total;
var attSkill = rollsAttack.inlinerolls[attSkillNumber].results.total;
evt.type = 'Attaque';
evt.succes = true;
evt.action.player_id = playerId;
evt.action.attaquant = attaquant;
evt.action.cibles = cibles;
evt.action.attack_label = attackLabel;
evt.action.rollsAttack = rollsAttack;
addEvent(evt);
// debut de la partie affichage
var action = "<b>Arme</b> : ";
if (options.sortilege) action = "<b>Sort</b> : ";
var label_type = BS_LABEL_INFO;
var target = cibles[0];
if (options.aoe || cibles.length > 1) {
target = undefined;
label_type = BS_LABEL_WARNING;
}
action += "<span style='" + BS_LABEL + " " + label_type + "; text-transform: none; font-size: 100%;'>" + weaponName + "</span>";
var display = startFramedDisplay(playerId, action, attaquant, {
perso2: target,
chuchote: options.secret,
retarde: options.secret,
auto: options.auto || options.ouvertureMortelle
});
// Cas des armes à poudre
if (options.poudre) {
var poudreNumber = rollNumber(afterEvaluateAttack[2]);
var dePoudre = rollsAttack.inlinerolls[poudreNumber].results.total;
explications.push(
"Dé de poudre : " + buildinline(rollsAttack.inlinerolls[poudreNumber]));
if (dePoudre === 1) {
evt.succes = false;
if (d20roll === 1) {
explications.push(
weaponName + " explose ! L'arme est complètement détruite");
sendChat("", "[[2d6]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var r = {
total: explRoll.results.total,
type: 'normal',
display: buildinline(explRoll, 'normal')
};
dealDamage(attaquant, r, [], evt, false, options, explications,
function(dmgDisplay, dmg) {
var dmgMsg = "<b>Dommages pour " + attackerTokName + " :</b> " +
dmgDisplay;
addLineToFramedDisplay(display, dmgMsg);
finaliseDisplay(display, explications, evt, attaquant, cibles, options);
});
});
} else {
explications.push(
"La poudre explose dans " + weaponName +
". L'arme est inutilisable jusqu'à la fin du combat");
sendChat("", "[[1d6]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var r = {
total: explRoll.results.total,
type: 'normal',
display: buildinline(explRoll, 'normal')
};
dealDamage(attaquant, r, [], evt, false, options, explications,
function(dmgDisplay, dmg) {
var dmgMsg =
"<b>Dommages pour " + attackerTokName + " :</b> " +
dmgDisplay;
addLineToFramedDisplay(display, dmgMsg);
finaliseDisplay(display, explications, evt, attaquant, cibles, options);
});
});
}
return;
} else if (d20roll == dePoudre) {
evt.succes = false;
addLineToFramedDisplay(display,
"<b>Attaque :</b> " +
buildinline(rollsAttack.inlinerolls[attRollNumber]));
explications.push(weaponName + " fait long feu, le coup ne part pas");
finaliseDisplay(display, explications, evt, attaquant, cibles, options);
return;
}
}
//Modificateurs en Attaque qui ne dépendent pas de la cible
var attBonusCommun =
bonusAttaqueA(attaquant, weaponName, evt, explications, options);
if (options.traquenard) {
if (attributeAsInt(attaquant, 'traquenard', 0) === 0) {
sendChar(attackingCharId, "ne peut pas faire de traquenard, car ce n'est pas sa première attaque du combat");
return;
}
options.traquenard = tokenInit(attaquant, evt);
}
if (attributeAsInt(attaquant, 'traquenard', 0) > 0) {
setTokenAttr(attaquant, 'traquenard', 0, evt);
}
if (options.feinte) explications.push("Mais c'était une feinte...");
var mainDmgType = options.type || 'normal';
if (options.sortilege) options.ignoreObstacles = true;
var critSug; //Suggestion en cas d'écher critique
//Calcul des cibles touchées
//(et on ajuste le jet pour la triche)
var ciblesTouchees = [];
var count = cibles.length;
cibles.forEach(function(target) {
if (attributeAsBool(attaquant, 'menaceManoeuvre(' + target.token.id + ')')) {
explications.push(attaquant.tokName + " attaque " + target.tokName + " malgré la menace. " + target.tokName + " a droit à une attaque au contact gratuite.");
removeTokenAttr(attaquant, 'menaceManoeuvre(' + target.token.id + ')', evt);
setTokenAttr(attaquant, 'attaqueMalgreMenace(' + target.token.id + ')', 1, evt, undefined);
} else if (attributeAsBool(attaquant, 'menaceManoeuvre(' + target.token.id + ',crit)')) {
explications.push(attaquant.tokName + " attaque " + target.tokName + " malgré la menace. " + target.tokName + " a droit à une attaque au contact gratuite (DM x 2 !).");
removeTokenAttr(attaquant, 'menaceManoeuvre(' + target.token.id + ',crit)', evt);
setTokenAttr(attaquant, 'attaqueMalgreMenace(' + target.token.id + ')', 2, evt, undefined);
}
target.additionalDmg = [];
target.messages = [];
var amm = 'attaqueMalgreMenace(' + attaquant.token.id + ')';
if (options.contact && cibles.length == 1) {
if (attributeAsBool(target, amm)) {
target.messages.push('Attaque automatique suite à une menace ignorée');
options.auto = true;
if (attributeAsInt(target, amm, 1) > 1) options.dmFoisDeux = true;
target.additionalDmg.push({
type: mainDmgType,
value: '1d6'
});
removeTokenAttr(target, amm, evt);
} else if (attributeAsBool(attaquant, 'attaqueGratuiteAutomatique(' + target.token.id + ')')) {
options.auto = true;
removeTokenAttr(attaquant, 'attaqueGratuiteAutomatique(' + target.token.id + ')', evt);
}
}
//Les bonus d'attaque qui dépendent de la cible
var bad = bonusAttaqueD(attaquant, target, weaponStats.portee, pageId, evt, target.messages, options);
var attBonus = attBonusCommun + bad;
if (options.traquenard) {
var initTarg = tokenInit(target, evt);
if (options.traquenard >= initTarg) {
attBonus += 2;
target.additionalDmg.push({
type: mainDmgType,
value: '2' + options.d6
});
target.messages.push(attackerTokName + " fait un traquenard à " + target.tokName);
} else {
target.messages.push(attackerTokName + " n'est pas assez rapide pour faire un traquenard à " + target.tokName);
}
}
var defautCuirasse =
tokenAttribute(target, 'defautDansLaCuirasse_' + attackerTokName);
target.crit = crit;
if (defautCuirasse.length > 0) {
target.defautCuirasse = true;
if (target.crit > 2) target.crit -= 1;
}
//Defense de la cible
var defense = defenseOfToken(attaquant, target, pageId, evt, options);
var interchange;
if (options.aoe === undefined) {
interchange = interchangeable(attackingToken, target, pageId);
if (interchange.result) {
if (stateCOF.options.regles.val.interchangeable_attaque.val) {
defense += 2;
} else {
defense += 5;
}
}
}
//Absorption au bouclier
var absorber;
if (target.absorber) {
explications = explications.concat(target.absorberExpl);
if (target.absorber > defense) {
defense = target.absorber;
absorber = target.absorberDisplay;
}
}
var touche = true;
var critique = false;
// Calcule si touché, et les messages de dégats et attaque
if (!options.auto && !options.interposer) {
if (options.triche) {
switch (options.triche) {
case "rate":
if (d20roll >= target.crit) {
if (target.crit < 2) d20roll = 1;
else d20roll = randomInteger(target.crit - 1);
}
if ((d20roll + attSkill + attBonus) >= defense) {
var maxd20roll = defense - attSkill - attBonus - 1;
if (maxd20roll >= target.crit) maxd20roll = target.crit - 1;
if (maxd20roll < 2) d20roll = 1;
else d20roll = randomInteger(maxd20roll);
}
break;
case "touche":
if (d20roll == 1) d20roll = randomInteger(dice - 1) + 1;
if ((d20roll + attSkill + attBonus) < defense) {
var mind20roll = defense - attSkill - attBonus - 1;
if (mind20roll < 1) mind20roll = 1;
if (mind20roll >= dice) d20roll = dice;
else d20roll = randomInteger(dice - mind20roll) + mind20roll;
}
break;
case "critique":
if (d20roll < target.crit) {
if (target.crit <= dice) d20roll = randomInteger(dice - target.crit + 1) + target.crit - 1;
else d20roll = dice;
}
break;
case "echecCritique":
if (d20roll > 1) d20roll = 1;
break;
default:
error("Option inconnue", options.triche);
}
// now adjust the roll
var attackInlineRoll = rollsAttack.inlinerolls[attRollNumber];
attackInlineRoll.results.total = d20roll;
attackInlineRoll.results.rolls.forEach(function(roll) {
if (roll.type == 'R' && roll.results.length == 1) {
roll.results[0].v = d20roll;
}
});
}
var attackRoll = d20roll + attSkill + attBonus;
var attackResult; // string
var paralyse = false;
if (getState(target, 'paralyse')) {
paralyse = true;
if (!options.attaqueAssuree)
target.messages.push("Cible paralysée => réussite critique automatique");
}
if (d20roll >= 15) {
if (charAttributeAsBool(attaquant, 'champion'))
options.champion = true;
if (charAttributeAsBool(attaquant, 'agripper'))
options.agripper = true;
}
if (d20roll >= 17 && options.contact &&
charAttributeAsBool(attaquant, 'crocEnJambe')) {
if (d20roll >= 19 || !estQuadrupede(target)) {
setState(target, 'renverse', true, evt);
target.messages.push("tombe par terre");
}
}
if (d20roll == 1 && options.chance === undefined) {
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_DANGER + "'><b>échec critique</b></span>";
if (options.demiAuto) {
target.partialSaveAuto = true;
evt.succes = false;
} else touche = false;
var confirmCrit = randomInteger(20);
critSug = "/w GM Jet de confirmation pour l'échec critique : " +
confirmCrit + "/20. Suggestion d'effet : ";
switch (confirmCrit) {
case 1:
critSug += "l'attaquant se blesse ou est paralysé un tour";
break;
case 2:
critSug += "l'attaquant blesse un allié";
break;
case 3:
critSug += "l'arme casse, ou une pièce d'armure se détache, ou -5 DEF un tour (comme surpris)";
break;
case 4:
critSug += "l'attaquant lache son arme ou glisse et tombe";
break;
default:
critSug += "simple échec";
}
} else if ((paralyse || options.ouvertureMortelle || d20roll == 20 ||
(d20roll >= target.crit && attackRoll >= defense)) && !options.attaqueAssuree) {
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>réussite critique</b></span>";
touche = true;
critique = true;
} else if (options.champion || d20roll == 20 || paralyse) {
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>succès</b></span>";
} else if (attackRoll < defense && d20roll < target.crit) {
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_WARNING + "'><b>échec</b></span>";
evt.succes = false;
if (options.demiAuto) {
target.partialSaveAuto = true;
} else touche = false;
} else if (d20roll % 2 && attributeAsBool(target, 'clignotement')) {
target.messages.push(target.tokName + " disparaît au moment où l'attaque aurait du l" + onGenre(target.charId, 'e', 'a') + " toucher");
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_WARNING + "'><b>échec</b></span>";
target.clignotement = true;
if (options.demiAuto) {
target.partialSaveAuto = true;
} else touche = false;
} else { // Touché normal
attackResult = " : <span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>succès</b></span>";
}
var attRollValue = buildinline(rollsAttack.inlinerolls[attRollNumber]);
if (attSkill > 0) attRollValue += "+" + attSkill;
else if (attSkill < 0) attRollValue += attSkill;
if (attBonus > 0) attRollValue += "+" + attBonus;
else if (attBonus < 0) attRollValue += attBonus;
var line = "<b>Attaque</b> ";
if (options.aoe || cibles.length > 1) {
line += "contre <b>" + target.tokName + "</b> ";
}
line += ":<br>";
line += attRollValue + ' ';
if (stateCOF.options.affichage.val.montre_def.val) {
line += "vs <b>";
if (absorber) line += absorber;
else line += defense;
line += "</b> ";
}
line += attackResult;
if (options.test) line += " (" + attackRoll + ")";
target.attackMessage = line;
if (touche) {
if (options.asDeLaGachette && attackRoll > 24) {
target.messages.push("As de la gachette : + 1" + options.d6 + " aux DM");
target.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
}
} else { //Effet si on ne touche pas
// Draw failed effect
if (_.has(options, "fx") && options.distance) {
var p1 = {
x: attackingToken.get('left'),
y: attackingToken.get('top')
};
var p2 = {
x: target.token.get('left'),
y: target.token.get('top')
};
// Compute some gaussian deviation in [0, 1]
var dev =
(Math.random() + Math.random() + Math.random() + Math.random() +
Math.random() + 1) / 6;
// take into account by how far we miss
dev = dev * (d20roll == 1) ? 2 : ((attackRoll - defense) / 20);
if (Math.random() > 0.5) dev = -dev;
p2.x += dev * (p2.y - p1.y);
p2.y += dev * (p2.x - p1.x);
spawnFxBetweenPoints(p1, p2, options.fx, pageId);
}
if (target.clignotement === undefined) {
evt.succes = false;
diminueMalediction(attaquant, evt);
}
}
}
target.touche = touche;
target.critique = critique;
if (options.aoe === undefined && interchange.targets.length > 1) { //any target can be affected
var n = randomInteger(interchange.targets.length);
target.token = interchange.targets[n - 1];
}
if (target.touche &&
attributeAsBool(target, 'imageDecalee')) {
var id = rollDePlus(6);
if (id.val > 4) {
target.touche = false;
target.messages.push(id.roll + ": l'attaque passe à travers l'image de " + target.tokName);
} else {
target.messages.push(id.roll + ": malgré l'image légèrement décalée de " + target.tokName + " l'attaque touche");
}
}
if (target.touche) {
ciblesTouchees.push(target);
if (attributeAsBool(target, 'esquiveFatale')) {
var ennemisAuContact = target.ennemisAuContact;
if (ennemisAuContact === undefined) {
error("Les ennemis au contact n'ont pas été déterminé");
} else {
var iOther = ennemisAuContact.find(function(tok) {
return (tok.id != attaquant.token.id);
});
if (iOther !== undefined)
target.messages.push(bouton("!cof-esquive-fatale " + evt.id + " @{target|token_id}", "Esquive fatale ?", target));
}
}
}
if (options.test || options.feinte || !target.touche) {
//On a fini avec cette cible, on imprime ce qui la concerne
addLineToFramedDisplay(display, target.attackMessage);
target.messages.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
}
if (options.feinte) {
setTokenAttr(target, 'feinte_' + attaquant.tokName, 0, evt, undefined, target.touche);
}
count--;
if (count === 0)
attackDealDmg(attaquant, ciblesTouchees, critSug, attackLabel, weaponStats, d20roll, display, options, evt, explications, pageId, cibles);
}); //fin de détermination de toucher des cibles
}); // fin du jet d'attaque asynchrone
}
function computeMainDmgRollExpr(attaquant, target, weaponStats, attNbDices, attDMBonus, options) {
var attDMArme = weaponStats.attDMBonusCommun;
if (isNaN(attDMArme) || attDMArme === 0) attDMArme = '';
else if (attDMArme > 0) attDMArme = '+' + attDMArme;
attDMBonus = attDMArme + attDMBonus;
var attNbDicesCible = attNbDices;
var attDiceCible = computeAttackDice(weaponStats.attDice, options);
var attCarBonusCible =
computeAttackCarBonus(attaquant, weaponStats.attCarBonus);
if (target.pressionMortelle) {
attNbDicesCible = 1;
attDiceCible = 6; //TODO : have an option for that
attCarBonusCible = '';
}
if (!options.sortilege && charAttributeAsBool(target, 'immuniteAuxArmes')) {
if (options.magique) {
attNbDicesCible = options.magique;
attDiceCible = "6";
attCarBonusCible = modCarac(target, 'SAGESSE');
if (attCarBonusCible < 1) attCarBonusCible = "";
else attCarBonusCible = " +" + attCarBonusCible;
} else {
target.messages.push(target.tokName + " semble immunisé aux armes ordinaires");
attNbDicesCible = 0;
attCarBonusCible = "";
attDMBonus = "";
}
}
var symbde = 'd';
if (target.maxDmg) symbde = '*';
return addOrigin(attaquant.name, attNbDicesCible + symbde + attDiceCible + attCarBonusCible + attDMBonus);
}
function computeAttackDice(d, options) {
if (isNaN(d) || d < 0) {
error("Dé d'attaque incorrect", d);
return 0;
}
var attDice = d;
if (options.puissant) {
attDice += 2;
}
if (options.reroll1) attDice += "r1";
if (options.reroll2) attDice += "r2";
if (options.explodeMax) attDice += '!';
return attDice;
}
//retourne le mod de la caractéristique x, undefined si ce n'en est pas une
function computeCarExpression(perso, x) {
switch (x) {
case '@{FOR}':
return modCarac(perso, 'FORCE');
case '@{DEX}':
return modCarac(perso, 'DEXTERITE');
case '@{CON}':
return modCarac(perso, 'CONSTITUTION');
case '@{INT}':
return modCarac(perso, 'INTELLIGENCE');
case '@{SAG}':
return modCarac(perso, 'SAGESSE');
case '@{CHA}':
return modCarac(perso, 'CHARISME');
default:
return;
}
}
function computeAttackCarBonus(attaquant, x) {
if (x === undefined) return '';
var attCarBonus = x;
if (isNaN(attCarBonus)) {
var simplerAttCarBonus = computeCarExpression(attaquant, x);
if (simplerAttCarBonus !== undefined) {
attCarBonus = simplerAttCarBonus;
}
}
if (attCarBonus === "0" || attCarBonus === 0) attCarBonus = "";
else attCarBonus = " + " + attCarBonus;
return attCarBonus;
}
function computeArmeAtk(attaquant, x) {
if (x === undefined) return '';
var attDiv;
var attCar;
switch (x) {
case '@{ATKCAC}':
attDiv = ficheAttributeAsInt(attaquant, 'ATKCAC_DIV', 0);
attCar = getAttrByName(attaquant.charId, 'ATKCAC_CARAC');
break;
case '@{ATKTIR}':
attDiv = ficheAttributeAsInt(attaquant, 'ATKTIR_DIV', 0);
attCar = getAttrByName(attaquant.charId, 'ATKTIR_CARAC');
break;
case '@{ATKMAG}':
attDiv = ficheAttributeAsInt(attaquant, 'ATKMAG_DIV', 0);
attCar = getAttrByName(attaquant.charId, 'ATKMAG_CARAC');
break;
default:
return x;
}
attCar = computeCarExpression(attaquant, attCar);
if (attCar === undefined) return x;
return attCar + ficheAttributeAsInt(attaquant, 'NIVEAU', 1) + attDiv;
}
function attackDealDmg(attaquant, cibles, critSug, attackLabel, weaponStats, d20roll, display, options, evt, explications, pageId, ciblesAttaquees) {
if (cibles.length === 0 || options.test || options.feinte) {
finaliseDisplay(display, explications, evt, attaquant, ciblesAttaquees, options);
if (critSug) sendChat('COF', critSug);
return;
}
var attackingCharId = attaquant.charId;
var attackingToken = attaquant.token;
var attackerTokName = attaquant.tokName;
options.attaquant = attaquant;
//Les dégâts
//Dégâts insrits sur la ligne de l'arme
var mainDmgType = options.type || 'normal';
var attNbDices = weaponStats.attNbDices;
if (isNaN(attNbDices) || attNbDices < 0) {
error("Dés de l'attaque incorrect", attNbDices);
return;
}
if (attNbDices) {
if (options.tempeteDeManaIntense) {
attNbDices += options.tempeteDeManaIntense;
} else if (options.conditionAttaquant &&
options.conditionAttaquant.type == 'attribut') {
var attrtdmi =
options.conditionAttaquant.attribute + "TempeteDeManaIntense";
var tdmCond = attributeAsInt(attaquant, attrtdmi, 0);
if (tdmCond) {
attNbDices += tdmCond;
removeTokenAttr(attaquant, attrtdmi, evt);
}
}
}
// Les autres modifications aux dégâts qui ne dépendent pas de la cible
var attDMBonusCommun = '';
if (options.rayonAffaiblissant) {
attDMBonusCommun += " -2";
}
if (attributeAsBool(attaquant, 'masqueDuPredateur')) {
var bonusMasque = getValeurOfEffet(attaquant, 'masqueDuPredateur', modCarac(attaquant, 'SAGESSE'));
if (bonusMasque > 0) attDMBonusCommun += " +" + bonusMasque;
}
if (options.rageBerserk) {
options.additionalDmg.push({
type: mainDmgType,
value: options.rageBerserk + options.d6
});
}
if (attributeAsBool(attaquant, 'enragé')) {
options.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
}
if (options.contact && attributeAsBool(attaquant, 'memePasMalBonus')) {
options.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6,
});
explications.push("Même pas mal => +1" + options.d6 + " DM");
}
var attrPosture = tokenAttribute(attaquant, 'postureDeCombat');
if (attrPosture.length > 0) {
attrPosture = attrPosture[0];
var posture = attrPosture.get('max');
var postureVal;
if (posture.startsWith('DM')) {
postureVal = parseInt(attrPosture.get('current'));
attDMBonusCommun += " -" + postureVal;
explications.push("Posture de combat => -" + postureVal + " DM");
} else if (posture.endsWith('DM')) {
postureVal = parseInt(attrPosture.get('current'));
attDMBonusCommun += " +" + postureVal;
explications.push("Posture de combat => +" + postureVal + " DM");
}
}
if (aUnCapitaine(attaquant, evt, pageId)) attDMBonusCommun += " +2";
// Les autres sources de dégâts
if (options.distance) {
if (options.semonce) {
options.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
explications.push("Tir de semonce => +5 en Attaque et +1" + options.d6 + " aux DM");
}
} else { //bonus aux attaques de contact
if (attributeAsBool(attaquant, 'agrandissement')) {
attDMBonusCommun += "+2";
explications.push("Agrandissement => +2 aux DM");
}
if (attributeAsBool(attaquant, 'forceDeGeant')) {
var bonusForceDeGeant = getValeurOfEffet(attaquant, 'forceDeGeant', 2);
attDMBonusCommun += "+" + bonusForceDeGeant;
explications.push("Force de géant => +" + bonusForceDeGeant + " aux DM");
}
if (options.frappeDuVide) {
options.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
}
}
var attrForgeron = 'forgeron(' + attackLabel + ')';
if (attributeAsBool(attaquant, attrForgeron)) {
var feuForgeron = getValeurOfEffet(attaquant, attrForgeron, 1, 'voieDuMetal');
var feuForgeronIntense = attributeAsInt(attaquant, attrForgeron + 'TempeteDeManaIntense', 0);
if (feuForgeronIntense) {
feuForgeron = feuForgeron * (1 + feuForgeronIntense);
removeTokenAttr(attaquant, attrForgeron + 'TempeteDeManaIntense', evt);
}
options.additionalDmg.push({
type: 'feu',
value: feuForgeron
});
}
var attrAEF = 'armeEnflammee(' + attackLabel + ')';
var nAEF = 0;
if (attributeAsBool(attaquant, attrAEF)) {
nAEF = 1;
var AEFIntense = attributeAsInt(attaquant, attrAEF + 'TempeteDeManaIntense', 0);
if (AEFIntense) {
nAEF += AEFIntense;
removeTokenAttr(attaquant, attrAEF + 'TempeteDeManaIntense', evt);
}
}
if (nAEF === 0 && attributeAsBool(attaquant, 'armesEnflammees')) {
nAEF = 1;
var AsEFIntense = attributeAsInt(attaquant, 'armesEnflammeesTempeteDeManaIntense', 0);
if (AsEFIntense) {
nAEF += AsEFIntense;
removeTokenAttr(attaquant, 'armesEnflammeesTempeteDeManaIntense', evt);
}
}
if (nAEF > 0) {
options.additionalDmg.push({
type: 'feu',
value: nAEF + 'd6'
});
}
var poisonAttr = tokenAttribute(attaquant, 'poisonRapide_' + attackLabel);
if (poisonAttr.length > 0) {
poisonAttr = poisonAttr[0];
options.additionalDmg.push({
type: 'poison',
value: poisonAttr.get('current'),
partialSave: {
carac: 'CON',
seuil: poisonAttr.get('max')
}
});
explications.push("L'arme est empoisonnée");
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(poisonAttr);
poisonAttr.remove();
}
var attrDmgArme = 'dmgArme(' + attackLabel + ')';
if (charAttributeAsBool(attaquant, attrDmgArme)) {
var dmgArme = {
type: mainDmgType,
value: '1' + options.d6
};
var valDmgArme = tokenAttribute(attaquant, attrDmgArme + 'Valeur');
if (valDmgArme.length > 0) {
dmgArme.value = valDmgArme[0].get('current');
var dmgArmeType = valDmgArme[0].get('max');
if (dmgArmeType !== '') dmgArme.type = dmgArmeType;
}
options.additionalDmg.push(dmgArme);
explications.push("Arme enduite => +" + dmgArme.value + " aux DM");
}
if (options.champion) {
options.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
explications.push(attackerTokName + " est un champion, son attaque porte !");
}
/////////////////////////////////////////////////////////////////
//Tout ce qui dépend de la cible
var ciblesCount = cibles.length; //Pour l'asynchronie
var attaquesEnTraitrePossibles = {};
var finCibles = function() {
ciblesCount--;
if (ciblesCount === 0) {
cibles.forEach(function(target) {
if (target.attackMessage) {
addLineToFramedDisplay(display, target.attackMessage);
} else if (options.aoe) { //par exemple si attaque automatique
addLineToFramedDisplay(display, "<b>" + target.tokName + "</b> :");
}
if (target.dmgMessage) addLineToFramedDisplay(display, target.dmgMessage, 100, false);
target.messages.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
});
finaliseDisplay(display, explications, evt, attaquant, ciblesAttaquees, options);
for (var vid in attaquesEnTraitrePossibles) {
var voleur = tokenOfId(vid);
if (voleur === undefined) continue;
var attaqueEnTraitre = tokenAttribute(voleur, 'attaqueEnTraitre');
if (attaqueEnTraitre.length === 0) {
error("Impossible de trouver l'attribut d'attaque en traître", voleur);
continue;
}
attaqueEnTraitre = attaqueEnTraitre[0];
var curAttaqueEnTraitre = parseInt(attaqueEnTraitre.get('current'));
if (isNaN(curAttaqueEnTraitre)) {
error("Resource pour attaque en traître mal formée", attaqueEnTraitre);
continue;
}
if (curAttaqueEnTraitre > 0) {
displayAttaqueOpportunite(vid, attaquesEnTraitrePossibles[vid], "en traître", '#AttaqueEnTraitre#', '--decrAttribute ' + attaqueEnTraitre.id);
}
}
}
};
cibles.forEach(function(target) {
target.ignoreRD = options.ignoreRD;
target.ignoreMoitieRD = options.ignoreMoitieRD;
target.tempDmg = options.tempDmg;
target.enflamme = options.enflamme;
target.malediction = options.malediction;
target.pietine = options.pietine;
target.maxDmg = options.maxDmg;
evalITE(attaquant, target, d20roll, options, evt, explications, options);
if (options.enveloppe !== undefined) {
var ligneEnveloppe = attaquant.tokName + " peut ";
var commandeEnvelopper =
'!cof-enveloppement ' + attaquant.token.id + ' ' + target.token.id + ' ' +
options.enveloppe.difficulte + ' ' +
options.enveloppe.type + ' ' + options.enveloppe.expression;
ligneEnveloppe += boutonSimple(commandeEnvelopper, '', 'envelopper');
ligneEnveloppe += target.tokName;
target.messages.push(ligneEnveloppe);
}
if (options.agripper) {
var immobilise = estAussiGrandQue(attaquant, target);
setTokenAttr(attaquant, 'agrippe', target.token.id + ' ' + target.tokName, evt);
setTokenAttr(target, 'estAgrippePar', attaquant.token.id + ' ' + attaquant.tokName, evt, undefined, immobilise);
if (immobilise) setState(target, 'immobilise', true, evt);
target.messages.push("est agrippé");
}
var attDMBonus = attDMBonusCommun;
//Les modificateurs de dégâts qui dépendent de la cible
if (target.tempDmg) {
var forceTarg = modCarac(target, "FORCE");
if (forceTarg < 0) {
attDMBonus += " +" + (-forceTarg);
} else {
attDMBonus += " -" + forceTarg;
}
}
if (options.pressionMortelle || target.pressionMortelle) {
var pMortelle = tokenAttribute(target, 'pressionMortelle');
if (pMortelle.length === 0) {
sendChar(attackingCharId, "Essaie une pression mortelle, mais aucun point vital de " + target.tokName + " n'a encore été affecté");
ciblesCount--;
return;
}
target.pressionMortelle = pMortelle;
attDMBonus = "+ " + pMortelle[0].get('current');
}
if (options.distance && !options.grenaille) {
var tirPrecis = charAttributeAsInt(attaquant, 'tirPrecis', 0);
if (tirPrecis > 0) {
var modDex = modCarac(attaquant, 'DEXTERITE');
if (target.distance <= 5 * modDex) {
attDMBonus += " + " + tirPrecis;
target.messages.push("Tir précis : +" + tirPrecis + " DM");
}
}
}
var sournoise = options.sournoise || 0;
if (target.sournoise) sournoise += target.sournoise;
if (sournoise) {
if (charAttributeAsBool(target, 'immuniteAuxSournoises')) {
target.messages.push('Immunité aux attaques sournoises');
} else {
if (options.ouvertureMortelle) {
target.messages.push("Ouverture mortelle => + 2 x " + sournoise + options.d6 + " DM");
sournoise = sournoise * 2;
} else {
target.messages.push("Attaque sournoise => +" + sournoise + options.d6 + " DM");
}
target.additionalDmg.push({
type: mainDmgType,
value: sournoise + options.d6
});
}
}
if (target.chasseurEmerite) {
attDMBonus += "+2";
}
if (target.ennemiJure) {
target.additionalDmg.push({
type: mainDmgType,
value: '1' + options.d6
});
}
if (target.tueurDeGeants) {
target.additionalDmg.push({
type: mainDmgType,
value: '2' + options.d6
});
}
if (target.armeDArgent) {
target.additionalDmg.push({
type: mainDmgType,
value: '1d6'
});
}
if (target.estAgrippee) {
target.additionalDmg.push({
type: mainDmgType,
value: '1d6'
});
}
var attrFeinte = tokenAttribute(target, 'feinte_' + attaquant.tokName);
if (attrFeinte.length > 0 && attrFeinte[0].get('current') &&
attrFeinte[0].get('max')) {
target.additionalDmg.push({
type: mainDmgType,
value: '2' + options.d6
});
}
var loupParmiLesLoups = charAttributeAsInt(attaquant, 'loupParmiLesLoups', 0);
if (loupParmiLesLoups > 0 && estHumanoide(target)) {
attDMBonus += "+" + loupParmiLesLoups;
target.messages.push("Loup parmi les loups : +" + loupParmiLesLoups + " DM");
}
//Bonus aux DMs dus au défi samouraï
var defiSamouraiAttr = tokenAttribute(attaquant, 'defiSamourai');
if (defiSamouraiAttr.length > 0) {
defiSamouraiAttr = defiSamouraiAttr[0];
var cibleDefi = defiSamouraiAttr.get('max');
if (cibleDefi.startsWith(target.token.id)) cibleDefi = true;
else {
var cibleDefiSep = cibleDefi.indexOf(' ');
var cibleDefiName = cibleDefi.substring(cibleDefiSep + 1);
if (cibleDefiName == target.tokName) {
var cibleDefiId = cibleDefi.substring(0, cibleDefiSep);
cibleDefi = tokenOfId(cibleDefiId, cibleDefiName, pageId);
cibleDefi = cibleDefi === undefined || cibleDefi.id == target.id;
} else cibleDefi = false;
}
if (cibleDefi) {
var bonusDefi = parseInt(defiSamouraiAttr.get('current'));
target.additionalDmg.push({
type: mainDmgType,
value: bonusDefi
});
target.messages.push(attackerTokName + " bénéficie d'un bonus de +" + bonusDefi + " aux DMs contre " + target.tokName);
}
}
if (attributeAsBool(attaquant, 'ombreMortelle') ||
attributeAsBool(attaquant, 'dedoublement') ||
(charAttributeAsBool(attaquant, 'armeeConjuree') && attributeAsBool(target, 'attaqueArmeeConjuree'))) {
if (options.divise) options.divise *= 2;
else options.divise = 2;
}
if (options.attaqueAssuree) {
if (options.divise) options.divise *= 2;
else options.divise = 2;
}
var mainDmgRollExpr =
computeMainDmgRollExpr(attaquant, target, weaponStats, attNbDices,
attDMBonus, options);
//Additional damage
var additionalDmg = options.additionalDmg.concat(target.additionalDmg);
//On enlève les DM qui ne passent pas les conditions
additionalDmg = additionalDmg.filter(function(dmSpec) {
if (dmSpec.conditions === undefined) return true;
return dmSpec.conditions.every(function(cond) {
return testCondition(cond, attaquant, [target], d20roll);
});
});
if (!options.sortilege && !options.magique &&
charAttributeAsBool(target, 'immuniteAuxArmes')) {
additionalDmg = additionalDmg.filter(function(dmSpec) {
switch (dmSpec.type) {
case undefined:
case 'normal':
case 'poison':
case 'maladie':
return false;
default:
return true;
}
});
}
if (options.tirDouble || options.tirDeBarrage || options.dmFoisDeux) {
if (options.tirDouble && options.tirDouble.stats) {
var stats2 = options.tirDouble.stats;
mainDmgRollExpr += " +" +
computeMainDmgRollExpr(attaquant, target, stats2, stats2.attNbDices,
attDMBonus, options);
} else {
mainDmgRollExpr += " +" + mainDmgRollExpr;
}
additionalDmg.forEach(function(dmSpec) {
dmSpec.value += " +" + dmSpec.Value;
});
}
var ExtraDmgRollExpr = "";
additionalDmg = additionalDmg.filter(function(dmSpec) {
dmSpec.type = dmSpec.type || 'normal';
if (dmSpec.type != mainDmgType || isNaN(dmSpec.value)) {
ExtraDmgRollExpr += " [[" + dmSpec.value + "]]";
return true;
}
// We have the same type and a constant -> should be multiplied by crit
mainDmgRollExpr += " + " + dmSpec.value;
return false;
});
if (options.aveugleManoeuvre) {
mainDmgRollExpr += " -5";
}
var mainDmgRoll = {
type: mainDmgType,
value: mainDmgRollExpr
};
// toEvaluateDmg inlines
// 0 : roll de dégâts principaux
// 1+ : les rolls de dégâts supplémentaires
var toEvaluateDmg = "[[" + mainDmgRollExpr + "]]" + ExtraDmgRollExpr;
sendChat(attaquant.name, toEvaluateDmg, function(resDmg) {
var rollsDmg = target.rollsDmg || resDmg[0];
var afterEvaluateDmg = rollsDmg.content.split(' ');
var mainDmgRollNumber = rollNumber(afterEvaluateDmg[0]);
mainDmgRoll.total = rollsDmg.inlinerolls[mainDmgRollNumber].results.total;
mainDmgRoll.display = buildinline(rollsDmg.inlinerolls[mainDmgRollNumber], mainDmgType, options.magique);
var correctAdditionalDmg = [];
additionalDmg.forEach(function(dmSpec, i) {
var rRoll = rollsDmg.inlinerolls[rollNumber(afterEvaluateDmg[i + 1])];
if (rRoll) {
correctAdditionalDmg.push(dmSpec);
dmSpec.total = dmSpec.total || rRoll.results.total;
var addDmType = dmSpec.type;
dmSpec.display = dmSpec.display || buildinline(rRoll, addDmType, options.magique);
} else { //l'expression de DM additionel est mal formée
error("Expression de dégâts supplémentaires mal formée : " + additionalDmg[i].value, additionalDmg[i]);
}
});
additionalDmg = correctAdditionalDmg;
if (target.touche) { //Devrait être inutile ?
if (options.tirDeBarrage) target.messages.push("Tir de barrage : undo si la cible décide de ne pas bouger");
if (options.pointsVitaux) target.messages.push(attackerTokName + " vise des points vitaux mais ne semble pas faire de dégâts");
if (options.pressionMortelle || target.pressionMortelle) {
removeTokenAttr(target, 'pressionMortelle', evt);
target.messages.push(attackerTokName + " libère la pression des points vitaux, l'effet est dévastateur !");
spawnFx(target.token.get('left'), target.token.get('top'), 'bomb-death', pageId);
}
if (options.pasDeDmg === undefined) { //si l'attaque fait des DM, possibilité d'attaque en traître
if (attaquant.alliesAvecAttaqueEnTraitre === undefined) {
attaquant.alliesAvecAttaqueEnTraitre = [];
//On cherche tous les alliés ayant l'attaque en traitre
var allies = alliesParPerso[attaquant.charId] || new Set();
allies.forEach(function(ci) {
var aet = findObjs({
_type: 'attribute',
_characterid: ci,
});
aet.forEach(function(a) {
var an = a.get('name');
if (an == 'attaqueEnTraitre' ||
an.startsWith('attaqueEnTraitre_')) {
if (a.get('current')) {
iterTokensOfAttribute(ci, pageId, 'attaqueEnTraitre', an,
function(tok) {
attaquant.alliesAvecAttaqueEnTraitre.push(tok);
}, {
onlyOnPage: true,
possiblementAbsent: true
});
}
}
});
});
}
attaquant.alliesAvecAttaqueEnTraitre.forEach(function(tok) {
if (tok.id == target.id) return;
if (distanceCombat(target.token, tok, pageId) === 0) {
var aetp = attaquesEnTraitrePossibles[tok.id];
if (aetp === undefined) {
aetp = [];
attaquesEnTraitrePossibles[tok.id] = aetp;
}
aetp.push(target);
}
});
}
// change l'état de la cible, si spécifié
if (target.enflamme) {
var enflammePuissance = 1;
if (options.puissant) enflammePuissance = 2;
setTokenAttr(target, 'enflamme', enflammePuissance, evt);
target.messages.push(target.tokName + " prend feu !");
}
if (target.malediction) {
setTokenAttr(target, 'malediction', 3, evt);
target.messages.push(target.tokName + " est maudit...");
}
// Draw effect, if any
if (options.fx) {
//Pour les cones, on fait un seul effet, car c'est bien géré.
if (!options.aoe || options.aoe.type != 'cone') {
var p1e = {
x: attackingToken.get('left'),
y: attackingToken.get('top'),
};
var p2e = {
x: target.token.get('left'),
y: target.token.get('top'),
};
spawnFxBetweenPoints(p1e, p2e, options.fx, pageId);
}
}
if (options.targetFx && !options.aoe) {
spawnFx(target.token.get('left'), target.token.get('top'), options.targetFx, pageId);
}
target.rollsDmg = rollsDmg;
// Compte le nombre de saves pour la synchronisation
// (On ne compte pas les psave, gérés dans dealDamage)
var saves = 0;
//ajoute les états sans save à la cible
var etats = options.etats;
if (target.etats) {
if (etats) etats = etats.concat(target.etats);
else etats = target.etats;
}
if (etats) {
etats.forEach(function(ce) {
if (ce.save) {
saves++;
return; //on le fera plus tard
}
if (testCondition(ce.condition, attaquant, [target], d20roll)) {
setState(target, ce.etat, true, evt);
target.messages.push(target.tokName + " est " + ce.etat + eForFemale(target.charId) + " par l'attaque");
if (ce.saveCarac) {
setTokenAttr(target, ce.etat + 'Save', ce.saveCarac, evt, undefined, ce.saveDifficulte);
}
} else {
if (ce.condition.type == "moins") {
target.messages.push(
"Grâce à sa " + ce.condition.text + ", " + target.tokName +
" n'est pas " + ce.etat + eForFemale(target.charId));
}
}
});
}
var savesEffets = 0;
// Ajoute les effets sans save à la cible
var effets = options.effets;
if (target.effets) {
if (effets) effets = effets.concat(target.effets);
else effets = target.effets;
}
if (effets) {
effets.forEach(function(ef) {
if (ef.save) {
saves++;
savesEffets++;
return; //on le fera plus tard
}
if (ef.effet == 'dedoublement') {
if (attributeAsBool(target, 'dedouble') ||
attributeAsBool(target, 'dedoublement')) {
target.messages.push(target.tokName + " a déjà été dédoublé pendant ce combat");
return;
}
target.messages.push("Un double translucide de " +
target.tokName + " apparaît. Il est aux ordres de " +
attackerTokName);
setTokenAttr(target, 'dedouble', true, evt);
copieToken(target, undefined, stateCOF.options.images.val.image_double.val,
"Double de " + target.tokName, 'dedoublement', ef.duree,
pageId, evt);
return;
}
if (ef.duree) {
if (ef.message)
target.messages.push(target.tokName + " " + ef.message.activation);
setTokenAttr(target, ef.effet, ef.duree, evt, undefined,
getInit());
switch (ef.effet) {
case 'aveugleTemp':
setState(target, 'aveugle', true, evt);
break;
case 'ralentiTemp':
setState(target, 'ralenti', true, evt);
break;
case 'paralyseTemp':
setState(target, 'paralyse', true, evt);
break;
case 'etourdiTemp':
setState(target, 'etourdi', true, evt);
break;
case 'affaibliTemp':
setState(target, 'affaibli', true, evt);
break;
}
var effet = messageEffetTemp[ef.effet];
if (effet && effet.statusMarker) {
affectToken(target.token, 'statusmarkers', target.token.get('statusmarkers'), evt);
target.token.set('status_' + effet.statusMarker, true);
}
} else { //On a un effet de combat
target.messages.push(target.tokName + " " + messageEffetCombat[ef.effet].activation);
setTokenAttr(target, ef.effet, true, evt);
}
if (ef.valeur !== undefined) {
setTokenAttr(target, ef.effet + "Valeur", ef.valeur, evt, undefined, ef.valeurMax);
}
if (options.tempeteDeManaIntense)
setTokenAttr(target, ef.effet + 'TempeteDeManaIntense', options.tempeteDeManaIntense, evt);
if (ef.saveParTour) {
setTokenAttr(target, ef.effet + "SaveParTour",
ef.saveParTour.carac, evt, undefined, ef.saveParTour.seuil);
}
});
}
// Tout ce qui se passe après les saves (autres que saves de diminution des dmg
var afterSaves = function() {
if (saves > 0) return; //On n'a pas encore fait tous les saves
if (options.pasDeDmg ||
(additionalDmg.length === 0 && mainDmgRoll.total === 0 &&
attNbDices === 0)) {
// Pas de dégâts, donc pas d'appel à dealDamage
finCibles();
} else {
dealDamage(target, mainDmgRoll, additionalDmg, evt, target.critique,
options, target.messages,
function(dmgDisplay, dmg) {
if (options.strigeSuce) {
var suce = attributeAsInt(attaquant, 'strigeSuce', 0);
if (suce === 0) {
setTokenAttr(attaquant, 'bufDEF', -3, evt);
target.messages.push(
attackerTokName + " s'agrippe à " + target.tokName +
" et commence à lui sucer le sang");
}
if (suce + dmg >= 6) {
target.messages.push(
"Repus, " + attackerTokName + " se détache et s'envole");
target.messages.push(target.tokName + " se sent un peu faible...");
setState(target, 'affaibli', true, evt);
var defbuf = attributeAsInt(attaquant, 'bufDEF', 0);
if (defbuf === -3) {
removeTokenAttr(attaquant, 'bufDEF', evt);
} else if (defbuf !== 0) {
setTokenAttr(attaquant, 'bufDEF', defbuf + 3, evt);
}
} else {
setTokenAttr(attaquant, 'strigeSuce', suce + dmg, evt);
if (suce > 0)
target.messages.push(
attackerTokName + " continue à sucer le sang de " + target.tokName);
}
}
if (options.vampirise || target.vampirise) {
soigneToken(attaquant, dmg, evt, function(soins) {
target.messages.push(
"L'attaque soigne " + attackerTokName + " de " + soins +
" PV");
});
}
target.dmgMessage = "<b>DM :</b> " + dmgDisplay;
if (options.contact) {
//Les DMs automatiques en cas de toucher une cible
if (attributeAsBool(target, 'sousTension')) {
ciblesCount++;
sendChat("", "[[1d6]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var r = {
total: explRoll.results.total,
type: 'electrique',
display: buildinline(explRoll, 'electrique', true)
};
dealDamage(attaquant, r, [], evt, false, options,
target.messages,
function(dmgDisplay, dmg) {
var dmgMsg =
"<b>Décharge électrique sur " + attackerTokName + " :</b> " +
dmgDisplay;
target.messages.push(dmgMsg);
finCibles();
});
});
}
if (attributeAsBool(target, 'sangMordant')) {
ciblesCount++;
sendChat("", "[[1d6]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var r = {
total: explRoll.results.total,
type: 'acide',
display: buildinline(explRoll, 'acide', true)
};
dealDamage(attaquant, r, [], evt, false, options,
target.messages,
function(dmgDisplay, dmg) {
var dmgMsg =
"<b>Le sang acide gicle sur " + attackerTokName + " :</b> " +
dmgDisplay + " DM";
target.messages.push(dmgMsg);
finCibles();
});
});
}
var attrDmSiToucheContact = findObjs({
_type: 'attribute',
_characterid: target.charId,
name: 'dmSiToucheContact'
});
attrDmSiToucheContact.forEach(function(dstc) {
ciblesCount++;
sendChat("", "[[" + dstc.get('current') + "]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var type = dstc.get('max');
var r = {
total: explRoll.results.total,
type: type,
display: buildinline(explRoll, type, true)
};
dealDamage(attaquant, r, [], evt, false, options,
target.messages,
function(dmgDisplay, dmg) {
var dmgMsg =
"<b>" + attackerTokName + " subit :</b> " +
dmgDisplay + " DM en touchant " + target.tokName;
target.messages.push(dmgMsg);
finCibles();
});
});
});
var attrCorpsElem = findObjs({
_type: 'attribute',
_characterid: target.charId,
name: 'corpsElementaire'
});
attrCorpsElem.forEach(function(dstc) {
ciblesCount++;
sendChat("", "[[1d6]]", function(res) {
var rolls = res[0];
var explRoll = rolls.inlinerolls[0];
var type = dstc.get('current');
var r = {
total: explRoll.results.total,
type: type,
display: buildinline(explRoll, type, true)
};
dealDamage(attaquant, r, [], evt, false, options,
target.messages,
function(dmgDisplay, dmg) {
var dmgMsg =
"<b>" + attackerTokName + " subit :</b> " +
dmgDisplay + " DM en touchant " + target.tokName;
target.messages.push(dmgMsg);
finCibles();
});
});
});
}
finCibles();
});
}
};
var expliquer = function(msg) {
target.messages.push(msg);
};
//Ajoute les états avec save à la cibles
var etatsAvecSave = function() {
if (savesEffets > 0) return; //On n'a pas encore fini avec les effets
if (etats && saves > 0) {
etats.forEach(function(ce) {
if (ce.save) {
if (testCondition(ce.condition, attaquant, [target], d20roll)) {
var msgPour = " pour résister à un effet";
var msgRate = ", " + target.tokName + " est " + ce.etat + eForFemale(target.charId) + " par l'attaque";
var saveOpts = {
msgPour: msgPour,
msgRate: msgRate,
attaquant: attaquant
};
save(ce.save, target, expliquer, saveOpts, evt,
function(reussite, rolltext) {
if (!reussite) {
setState(target, ce.etat, true, evt);
if (ce.saveCarac) {
setTokenAttr(target, ce.etat + 'Save', ce.saveCarac, evt, undefined, ce.saveDifficulte);
}
}
saves--;
afterSaves();
});
} else {
if (ce.condition.type == "moins") {
target.messages.push(
"Grâce à sa " + ce.condition.text + ", " + target.tokName +
" n'est pas " + ce.etat + eForFemale(target.charId));
}
saves--;
afterSaves();
}
}
});
} else afterSaves();
};
// Ajoute les effets avec save à la cible
var effetsAvecSave = function() {
if (effets && savesEffets > 0) {
effets.forEach(function(ef) {
if (ef.save) {
var msgPour = " pour résister à un effet";
var msgRate = ", " + target.tokName + " ";
if (ef.duree && ef.message)
msgRate += ef.message.activation;
else msgRate += messageEffetCombat[ef.effet].activation;
var saveOpts = {
msgPour: msgPour,
msgRate: msgRate,
attaquant: attaquant
};
var duree = ef.duree;
save(ef.save, target, expliquer, saveOpts, evt,
function(reussite, rollText) {
if (reussite && duree && ef.save.demiDuree) {
reussite = false;
duree = Math.ceil(duree / 2);
}
if (!reussite) {
if (ef.duree) {
setTokenAttr(target, ef.effet, duree, evt,
undefined, getInit());
switch (ef.effet) {
case 'aveugleTemp':
setState(target, 'aveugle', true, evt);
break;
case 'ralentiTemp':
setState(target, 'ralenti', true, evt);
break;
case 'paralyseTemp':
setState(target, 'paralyse', true, evt);
break;
case 'etourdiTemp':
setState(target, 'etourdi', true, evt);
break;
case 'affaibliTemp':
setState(target, 'affaibli', true, evt);
break;
}
var effet = messageEffetTemp[ef.effet];
if (effet && effet.statusMarker) {
affectToken(target.token, 'statusmarkers', target.token.get('statusmarkers'), evt);
target.token.set('status_' + effet.statusMarker, true);
}
} else setTokenAttr(target, ef.effet, true, evt);
if (ef.valeur !== undefined) {
setTokenAttr(target, ef.effet + "Valeur", ef.valeur, evt, undefined, ef.valeurMax);
}
if (options.tempeteDeManaIntense)
setTokenAttr(target, ef.effet + 'TempeteDeManaIntense', options.tempeteDeManaIntense, evt);
if (ef.saveParTour) {
setTokenAttr(target,
ef.effet + "SaveParTour", ef.saveParTour.carac,
evt, undefined, ef.saveParTour.seuil);
}
}
saves--;
savesEffets--;
etatsAvecSave();
});
}
});
} else etatsAvecSave();
};
var effetPietinement = function() {
if (target.pietine && estAussiGrandQue(attaquant, target)) {
testOppose(target, 'FOR', attaquant, 'FOR', target.messages, evt,
function(resultat) {
if (resultat == 2) {
target.messages.push(target.tokName + " est piétiné par " + attackerTokName);
setState(target, 'renverse', true, evt);
target.touche++;
} else {
if (resultat === 0) diminueMalediction(attaquant, evt);
target.messages.push(target.tokName + " n'est pas piétiné.");
}
effetsAvecSave();
});
} else effetsAvecSave();
};
// Peut faire peur à la cible
if (options.peur) {
peurOneToken(target, pageId, options.peur.seuil,
options.peur.duree, {
resisteAvecForce: true
}, target.messages, evt, effetPietinement);
} else effetPietinement();
} else {
evt.succes = false;
finCibles();
}
});
}); //Fin de la boucle pour toutes cibles
}
//Affichage final d'une attaque
// attaquant est optionnel, mais si il est présent, cibles doit être un tableau et options un objet
function finaliseDisplay(display, explications, evt, attaquant, cibles, options) {
explications.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
if (evt.action) {
evt.personnage = evt.action.attaquant;
if (evt.succes === false) {
var pc = pointsDeChance(evt.personnage);
if (pc > 0) {
addLineToFramedDisplay(display, bouton("!cof-bouton-chance " + evt.id, "Chance", evt.personnage) + " (reste " + pc + " PC)");
}
if (attributeAsBool(evt.personnage, 'runeDEnergie')) {
addLineToFramedDisplay(display, bouton("!cof-rune-energie " + evt.id, "Rune d'énergie", evt.personnage));
}
//TODO: pacte sanglant
} else {
if (evt.action.attack_label) {
var attLabel = evt.action.attack_label;
if (attributeAsBool(evt.personnage, 'runeDePuissance(' + attLabel + ')')) {
addLineToFramedDisplay(display,
bouton("!cof-rune-puissance " + attLabel + ' ' + evt.id,
"Rune de puissance", evt.personnage));
}
}
if (attributeAsBool(evt.personnage, 'kiai') && !attributeAsBool(evt.personnage, 'rechargeDuKiai')) {
addLineToFramedDisplay(display,
bouton("!cof-pousser-kiai " + evt.id, "Kiai", evt.personnage));
}
//Possibilité d'annuler l'attaque
if (evt.action.options && !evt.action.options.auto) {
//Seulement si elle n'est pas automatiquement réussie
var sort = false;
if (evt.action.options && evt.action.options.sortilege) sort = true;
if (evt.action.cibles) {
evt.action.cibles.forEach(function(target) {
if (attributeAsBool(target, 'encaisserUnCoup')) {
addLineToFramedDisplay(display, target.tokName + " peut " +
bouton("!cof-encaisser-un-coup " + evt.id,
"encaisser le coup", target)
);
}
if (attributeAsBool(target, 'esquiveAcrobatique')) {
addLineToFramedDisplay(display, target.tokName + " peut " +
bouton("!cof-esquive-acrobatique " + evt.id,
"tenter une esquive acrobatique", target)
);
}
if (sort) {
if (attributeAsBool(target, 'absorberUnSort')) {
addLineToFramedDisplay(display, target.tokName + " peut " +
bouton("!cof-absorber-au-bouclier " + evt.id,
"absorber le sort", target)
);
}
} else {
if (attributeAsBool(target, 'absorberUnCoup')) {
addLineToFramedDisplay(display, target.tokName + " peut " +
bouton("!cof-absorber-au-bouclier " + evt.id,
"absorber le coup", target)
);
}
}
});
}
}
}
}
if (options === undefined || !options.secret) sendChat("", endFramedDisplay(display));
if (attaquant) {
var playerIds;
if (options.secret) {
playerIds = getPlayerIds(attaquant);
playerIds.forEach(function(playerid) {
addFramedHeader(display, playerid, true);
sendChat('', endFramedDisplay(display));
});
addFramedHeader(display, undefined, 'gm');
sendChat('', endFramedDisplay(display));
}
cibles.forEach(function(target) {
if (options.secret) {
var addPlayers = getPlayerIds(target);
addPlayers.forEach(function(nid) {
if (!playerIds.includes(nid)) {
playerIds.push(nid);
addFramedHeader(display, nid, true);
sendChat('', endFramedDisplay(display));
}
});
}
if (charAttributeAsBool(target, 'seulContreTous')) {
displayAttaqueOpportunite(target.token.id, [attaquant], "de riposte", '#ActionsRiposte#');
} else if (charAttributeAsBool(target, 'riposte')) {
var attrRipostesDuTour = tokenAttribute(target, 'ripostesDuTour');
if (attrRipostesDuTour.length > 0) {
var ripostesDuTour =
attrRipostesDuTour[0].get('current').split(' ');
ripostesDuTour = new Set(ripostesDuTour);
if (ripostesDuTour.has(attaquant.token.id)) return;
ripostesDuTour = attrRipostesDuTour[0].get('max').split(' ');
ripostesDuTour = new Set(ripostesDuTour);
if (ripostesDuTour.has(attaquant.token.id)) return;
}
displayAttaqueOpportunite(target.token.id, [attaquant], "de riposte", '#ActionsRiposte#', '--riposte');
}
});
if (options.secret) {
if (!playerIds.includes('gm')) playerIds.push('gm');
}
}
}
// RD spécifique au type
function typeRD(perso, dmgType) {
if (dmgType === undefined || dmgType == 'normal') return 0;
return charAttributeAsInt(perso, 'RD_' + dmgType, 0);
}
function probaSucces(de, seuil, nbreDe) {
if (nbreDe == 2) {
var proba1 = probaSucces(de, seuil, 1);
return 1 - (1 - proba1) * (1 - proba1);
}
if (seuil < 2) seuil = 2; // 1 est toujours un échec
else if (seuil > 20) seuil = 20;
return ((de - seuil) + 1) / de;
}
function nbreDeTestCarac(carac, perso) {
var typeJet = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: carac + '_SUP'
});
if (typeJet.length === 0) return 1;
switch (typeJet[0].get('current')) {
case '@{JETNORMAL}':
case '@{jetnormal}':
return 1;
case '@{JETSUP}':
case '@{jetsup}':
case '@{JETSUPHERO}':
case '@{jetsuphero}':
return 2;
default:
error("Jet inconnu", typeJet[0].get('current'));
}
return 1;
}
// Meilleure carac parmis 2 pour un save.
function meilleureCarac(carac1, carac2, personnage, seuil) {
var bonus1 = bonusTestCarac(carac1, personnage);
if (carac1 == 'DEX') bonus1 += charAttributeAsInt(personnage, 'reflexesFelins', 0);
var bonus2 = bonusTestCarac(carac2, personnage);
if (carac2 == 'DEX') bonus2 += charAttributeAsInt(personnage, 'reflexesFelins', 0);
var nbrDe1 = nbreDeTestCarac(carac1, personnage);
var nbrDe2 = nbreDeTestCarac(carac2, personnage);
var de1 = deTest(personnage, carac1);
var proba1 = probaSucces(de1, seuil - bonus1, nbrDe1);
var de2 = deTest(personnage, carac2);
var proba2 = probaSucces(de2, seuil - bonus2, nbrDe2);
if (proba2 > proba1) return carac2;
return carac1;
}
//s représente le save, avec une carac, une carac2 optionnelle et un seuil
//expliquer est une fonction qui prend en argument un string et le publie
// options peut contenir les champs :
// - msgPour : message d'explication à afficher avant le jet
// - msgReussite : message à afficher en cas de réussite
// - msgRate : message à afficher si l'action rate
// - attaquant : le {charId, token} de l'attaquant contre lequel le save se fait (si il y en a un)
function save(s, target, expliquer, options, evt, afterSave) {
var bonus = 0;
if (options.attaquant &&
charAttributeAsBool(target, 'protectionContreLeMal') &&
estMauvais(options.attaquant)) {
var bonusProtectionContreLeMal = getValeurOfEffet(target, 'protectionContreLeMal', 2);
bonus += bonusProtectionContreLeMal;
expliquer("Protection contre le mal => +" + bonusProtectionContreLeMal + " au jet de sauvegarde");
}
var bonusAttrs = [];
var carac = s.carac;
//Cas où le save peut se faire au choix parmis 2 caracs
if (s.carac2) {
carac = meilleureCarac(carac, s.carac2, target, s.seuil);
}
if (carac == 'DEX') {
bonusAttrs.push('reflexesFelins');
}
if (!options.hideSaveTitle) {
var title = " Jet de " + carac + " " + s.seuil;
if (options.msgPour) title += options.msgPour;
expliquer(title);
}
testCaracteristique(target, carac, s.seuil, {
bonusAttrs: bonusAttrs,
bonus: bonus
}, evt,
function(tr) {
var smsg = target.token.get('name') + " fait " + tr.texte;
if (tr.reussite) {
smsg += " => réussite";
if (options.msgReussite) smsg += options.msgReussite;
} else {
smsg += " => échec";
if (options.msgRate) smsg += options.msgRate;
}
expliquer(smsg);
afterSave(tr.reussite, tr.texte);
});
}
function partialSave(ps, target, showTotal, dmgDisplay, total, expliquer, evt, afterSave) {
if (ps.partialSave !== undefined) {
if ((ps.partialSave.carac == 'CON' || ps.partialSave.carac2 == 'CON') && estNonVivant(target)) {
expliquer("Les créatures non-vivantes sont immnunisées aux attaques qui demandent un test de constitution");
afterSave({
succes: true,
dmgDisplay: '0',
total: 0,
showTotal: false
});
return;
}
if (target.partialSaveAuto) {
if (showTotal) dmgDisplay = '(' + dmgDisplay + ')';
afterSave({
succes: true,
dmgDisplay: dmgDisplay + '/2',
total: Math.ceil(total / 2),
showTotal: true
});
return;
}
save(ps.partialSave, target, expliquer, {
msgPour: " pour réduire les dégâts",
msgReussite: ", dégâts divisés par 2",
attaquant: ps.attaquant
}, evt,
function(succes, rollText) {
if (succes) {
if (showTotal) dmgDisplay = "(" + dmgDisplay + ")";
dmgDisplay = dmgDisplay + " / 2";
showTotal = true;
total = Math.ceil(total / 2);
} else {}
afterSave({
succes: succes,
dmgDisplay: dmgDisplay,
total: total,
showTotal: showTotal
});
});
} else afterSave();
}
function applyRDSauf(rds, dmgType, total, display, options) {
options = options || {};
var typeTrouve = function(t) {
return (t == dmgType || options[t]);
};
if (total) {
for (var saufType in rds) {
var rd = rds[saufType];
if (rd < 1) break;
var types = saufType.split('_');
if (types.find(typeTrouve)) break;
if (total < rd) {
display += "-" + total;
rds[saufType] -= total;
total = 0;
} else {
display += "-" + rd;
total -= rd;
rds[saufType] = 0;
}
}
}
return {
total: total,
display: display
};
}
//On a déterminé les DM du type principal(possiblement après save des dmgExtra, maintenant on applique les résistances, puis on ajoute les DM d'autres types
function dealDamageAfterDmgExtra(target, mainDmgType, dmgTotal, dmgDisplay, showTotal, dmgParType, dmgExtra, crit, options, evt, expliquer, displayRes) {
if (options.pointsVitaux && dmgTotal > 0) { //dégâts retardés pour une pression mortelle
var pMortelle = tokenAttribute(target, 'pressionMortelle');
var dmgPMort = dmgTotal;
var numberPMort = 1;
if (pMortelle.length > 0) {
dmgPMort += pMortelle[0].get('current');
numberPMort += pMortelle[0].get('max');
}
setTokenAttr(target, 'pressionMortelle', dmgPMort, evt, undefined,
numberPMort);
dmgTotal = 0;
}
if (charAttributeAsBool(target, 'immunite_' + mainDmgType)) {
if (expliquer) {
target.tokName = target.tokName || target.token.get('name');
expliquer(target.tokName + " ne semble pas affecté par le type " + mainDmgType);
}
dmgTotal = 0;
dmgDisplay = '0';
showTotal = false;
} else if (target.ignoreRD === undefined) {
var rdMain = typeRD(target, mainDmgType);
if (options.vampirise || target.vampirise) {
rdMain += attributeAsInt(target, 'RD_drain', 0);
}
if (target.ignoreMoitieRD) rdMain = parseInt(rdMain / 2);
if (rdMain > 0 && dmgTotal > 0) {
dmgTotal -= rdMain;
if (dmgTotal < 0) {
rdMain += dmgTotal;
dmgTotal = 0;
}
dmgDisplay += " - " + rdMain;
showTotal = true;
}
var rdElems = 0;
if (attributeAsBool(target, 'protectionContreLesElements')) {
rdElems = getValeurOfEffet(target, 'protectionContreLesElements', 1, 'voieDeLaMagieElementaire') * 2;
}
if (target.ignoreMoitieRD) rdElems = parseInt(rdElems / 2);
if (rdElems > 0 && dmgTotal > 0 && estElementaire(mainDmgType)) {
if (dmgTotal > rdElems) {
dmgDisplay += ' - ' + rdElems;
dmgTotal -= rdElems;
rdElems = 0;
} else {
dmgDisplay += ' - ' + dmgTotal;
rdElems -= dmgTotal;
dmgTotal = 0;
}
}
var rdSauf = [];
if (target.attrs === undefined) {
target.attrs = findObjs({
_type: 'attribute',
_characterid: target.charId
});
}
target.attrs.forEach(function(attr) {
var attrName = attr.get('name');
if (attrName.startsWith('RD_sauf_')) {
var rds = parseInt(attr.get('current'));
if (target.ignoreMoitieRD) rds = parseInt(rds / 2);
if (isNaN(rds) || rds < 1) return;
rdSauf[attrName.substr(8)] = rds;
}
});
if (attributeAsBool(target, 'formeDArbre')) {
rdSauf.feu_tranchant = rdSauf.feu_tranchant || 0;
if (target.ignoreMoitieRD) rdSauf.feu_tranchant += 5;
else rdSauf.feu_tranchant += 10;
}
var additionalType = {
magique: options.magique,
tranchant: options.tranchant,
percant: options.percant,
contondant: options.contondant
};
var resSauf = applyRDSauf(rdSauf, mainDmgType, dmgTotal, dmgDisplay, additionalType);
dmgTotal = resSauf.total;
dmgDisplay = resSauf.display;
var invulnerable = charAttributeAsBool(target, 'invulnerable');
var mitigate = function(dmgType, divide, zero) {
if (!options.sortilege && attributeAsBool(target, 'flou')) {
divide();
}
if (options.attaqueMentale && charAttributeAsBool(target, 'bouclierPsi')) {
divide();
}
if (options.aoe &&
(attributeAsBool(target, 'protectionDMZone') ||
attributeAsBool(target, 'protectionDMZone_' + dmgType))) {
divide();
expliquer(target.token.get('name') + " est protégé contre les dégâts de zone");
}
if (estElementaire(dmgType)) {
if (invulnerable) {
divide();
}
if (dmgType == 'froid' && attributeAsBool(target, 'masqueMortuaire')) {
divide();
}
if ((dmgType == 'feu' || dmgType == 'acide') && attributeAsBool(target, 'mutationEcaillesRouges')) {
divide();
} else if ((dmgType == 'froid' || dmgType == 'electrique') && attributeAsBool(target, 'mutationFourrureViolette')) {
divide();
}
} else {
if (dmgType == 'poison' || dmgType == 'maladie') {
if (invulnerable ||
charAttributeAsBool(target, 'creatureArtificielle') ||
estNonVivant(target)) {
zero();
} else if (attributeAsBool(target, 'mutationSangNoir')) {
divide();
}
} else if (attributeAsBool(target, 'armureMagique')) {
divide();
}
}
};
// Damage mitigaters for main damage
mitigate(mainDmgType,
function() {
dmgTotal = Math.ceil(dmgTotal / 2);
if (dmgExtra) dmgDisplay = "(" + dmgDisplay + ")";
dmgDisplay += " / 2";
showTotal = true;
},
function() {
dmgTotal = 0;
});
}
var dmSuivis = {}; //si il faut noter les DMs d'un type particulier
charAttribute(target.charId, 'vitaliteSurnaturelle').forEach(function(a) {
var typeVitalite = a.get('max').split(',');
typeVitalite.forEach(function(tv) {
if (tv == mainDmgType) dmSuivis[tv] = dmgTotal;
else dmSuivis[tv] = 0;
});
});
// Other sources of damage
// First count all other sources of damage, for synchronization
var count = 0;
for (var dt in dmgParType) {
if (charAttributeAsBool(target, 'immunite_' + dt)) {
if (expliquer) {
target.tokName = target.tokName || target.token.get('name');
expliquer(target.tokName + " ne semble pas affecté par le type " + dt);
}
delete dmgParType[dt];
} else
count += dmgParType[dt].length;
}
var critOther = crit && stateCOF.options.regles.val.crit_elementaire.val;
var dealOneType = function(dmgType) {
if (dmgType == mainDmgType) {
count -= dmgParType[dmgType].length;
if (count === 0) dealDamageAfterOthers(target, crit, options, evt, expliquer, displayRes, dmgTotal, dmgDisplay, showTotal, dmSuivis);
return; //type principal déjà géré
}
showTotal = true;
var dm = 0;
var typeDisplay = "";
var typeCount = dmgParType[dmgType].length;
dmgParType[dmgType].forEach(function(d) {
partialSave(d, target, false, d.display, d.total, expliquer, evt,
function(res) {
var addTypeDisplay = d.display;
if (res) {
dm += res.total;
if (critOther) {
dm += res.total;
if (options.memePasMal) options.memePasMal += res.total;
}
addTypeDisplay = res.dmgDisplay;
} else {
dm += d.total;
if (critOther) {
dm += d.total;
if (options.memePasMal) options.memePasMal += d.total;
}
}
if (critOther) addTypeDisplay = '(' + addTypeDisplay + ') x2';
if (typeDisplay === '') typeDisplay = addTypeDisplay;
else typeDisplay += "+" + addTypeDisplay;
typeCount--;
if (typeCount === 0) {
if (target.ignoreRD === undefined) {
var rdl = typeRD(target, dmgType);
if (target.ignoreMoitieRD) rdl = parseInt(rdl / 2);
if (rdl > 0 && dm > 0) {
dm -= rdl;
if (dm < 0) {
rdl += dm;
dm = 0;
}
typeDisplay += "-" + rdl;
}
if (rdElems > 0 && dm > 0 && estElementaire(dmgType)) {
if (dm > rdElems) {
typeDisplay += ' - ' + rdElems;
dm -= rdElems;
rdElems = 0;
} else {
typeDisplay += ' - ' + dm;
rdElems -= dm;
dm = 0;
}
}
var additionalType = {
magique: options.magique
};
var resSauf = applyRDSauf(rdSauf, dmgType, dm, typeDisplay, additionalType);
dm = resSauf.total;
typeDisplay = resSauf.display;
mitigate(dmgType,
function() {
dm = Math.ceil(dm / 2);
if (dmgParType[dmgType].length > 1) typeDisplay = "(" + typeDisplay + ")";
typeDisplay += " / 2";
},
function() {
dm = 0;
});
dmgTotal += dm;
dmgDisplay += "+" + typeDisplay;
if (_.has(dmSuivis, dmgType)) {
dmSuivis[dmgType] = dm;
}
}
}
count--;
if (count === 0) dealDamageAfterOthers(target, crit, options, evt, expliquer, displayRes, dmgTotal, dmgDisplay, showTotal, dmSuivis);
});
});
};
if (count > 0) {
for (var dmgType in dmgParType) {
dealOneType(dmgType);
}
} else {
return dealDamageAfterOthers(target, crit, options, evt, expliquer, displayRes, dmgTotal, dmgDisplay, showTotal, dmSuivis);
}
}
//Appelé quand on met à 0 PV
function mort(personnage, expliquer, evt) {
if (charAttributeAsBool(personnage, 'exsangue') && !attributeAsBool(personnage, 'etatExsangue')) {
var msg;
if (expliquer) {
personnage.tokName = personnage.tokName || personnage.token.get('name');
expliquer(personnage.tokName + " continue à agir malgré son état");
} else msg = "continue à agir malgré son état";
setTokenAttr(personnage, 'etatExsangue', true, evt, msg);
return;
}
setState(personnage, 'mort', true, evt);
var targetPos = {
x: personnage.token.get('left'),
y: personnage.token.get('top')
};
spawnFxBetweenPoints(targetPos, {
x: 400,
y: 400
}, "splatter-blood");
}
function dmgNaturel(options) {
if (options.nature) return true;
if (options.artificiel) return false;
var attaquant = options.attaquant;
if (attaquant === undefined) return false;
if (estAnimal(attaquant)) return true;
if (charAttributeAsBool(attaquant, 'insecte')) return true;
var attr = findObjs({
_type: 'attribute',
_characterid: attaquant.charId,
});
var attrProfile = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'PROFIL';
});
if (attrProfile.length > 0) {
if (attrProfile[0].get('current').trim().toLowerCase() == 'insecte') {
return true;
}
}
var attrRace = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'RACE';
});
if (attrRace.length === 0) return false;
var charRace = attrRace[0].get('current').trim().toLowerCase();
switch (charRace) {
case 'insecte':
case 'ankheg':
case 'araignée':
case 'araignee':
case 'guêpe':
case 'libellule':
case 'scarabée':
case 'scorpion':
case 'strige':
return true;
default:
return false;
}
}
function testBlessureGrave(target, dmgTotal, expliquer, evt) {
target.tokName = target.tokName || target.token.get('name');
if (stateCOF.options.regles.val.blessures_graves.val && estPJ(target) && (dmgTotal == 'mort' ||
dmgTotal >
(ficheAttributeAsInt(target, 'NIVEAU', 1) +
ficheAttributeAsInt(target, 'CONSTITUTION', 10)))) {
var pr = pointsDeRecuperation(target);
if (pr.current > 0) {
expliquer("Les dégâts sont si importants que " + target.tokName + " perd 1 PR");
enleverPointDeRecuperation(target, evt);
} else if (getState(target, 'blessé')) {
if (getState(target, 'mort')) {
expliquer("Avec la blessure grave, c'est vraiment la fin, " + target.tokName + " ne se relèvera plus...");
} else {
expliquer("Les dégâts sont trop importants, et " + target.tokName + " s'effondre");
mort(target, expliquer, evt);
}
} else {
setState(target, 'blessé', true, evt);
expliquer("Les dégâts occasionnent une blessure grave !");
}
}
}
function enlevePVStatueDeBois(perso, pvPerdus, evt) {
if (pvPerdus <= 0) return;
var attrs = tokenAttribute(perso, 'statueDeBoisValeur');
if (attrs.length === 0) return;
var cur = parseInt(attrs[0].get('current'));
var attrsB = tokenAttribute(perso, 'statueDeBois');
if (attrsB.length === 0) {
error("Attribut pour l'effet status de bois introuvable", cur);
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attrs[0]);
attrs[0].remove();
}
if (isNaN(cur)) {
finDEffet(attrsB[0], 'statueDeBois', attrsB[0].get('name'), perso.charId, evt);
return;
}
var newCur = cur - pvPerdus;
if (newCur <= 0) {
finDEffet(attrsB[0], 'statueDeBois', attrsB[0].get('name'), perso.charId, evt);
return;
}
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attrs[0],
current: cur,
max: attrs[0].get('max')
});
attrs[0].set('current', newCur);
}
function dealDamageAfterOthers(target, crit, options, evt, expliquer, displayRes, dmgTotal, dmgDisplay, showTotal, dmSuivis) {
var charId = target.charId;
var token = target.token;
// Now do some dmg mitigation rolls, if necessary
if ((options.distance || options.aoe) &&
attributeAsBool(target, 'aCouvert')) {
if (showTotal) dmgDisplay = "(" + dmgDisplay + ")";
dmgDisplay += " / 2";
dmgTotal = Math.ceil(dmgTotal / 2);
for (var dmType in dmSuivis) {
dmSuivis[dmType] = Math.ceil(dmSuivis[dmType] / 2);
}
showTotal = true;
}
partialSave(options, target, showTotal, dmgDisplay, dmgTotal,
expliquer, evt,
function(saveResult) {
if (saveResult) {
if (saveResult.total < dmgTotal) {
dmgTotal = saveResult.total;
for (var dmType in dmSuivis) {
dmSuivis[dmType] = Math.ceil(dmSuivis[dmType] / 2);
}
}
dmgDisplay = saveResult.dmgDisplay;
showTotal = saveResult.showTotal;
}
var rd = ficheAttributeAsInt(target, 'RDS', 0);
if (getAttrByName(target.charId, 'type_personnage') == 'PNJ') {
rd = ficheAttributeAsInt(target, 'pnj_rd', 0);
}
if (attributeAsBool(target, 'statueDeBois')) rd += 10;
if (attributeAsBool(target, 'mutationSilhouetteMassive')) rd += 3;
if (crit) {
var rdCrit = charAttributeAsInt(target, 'RD_critique', 0);
rd += rdCrit;
if (options.memePasMal) options.memePasMal -= rdCrit;
}
if (options.tranchant) rd += charAttributeAsInt(target, 'RD_tranchant', 0);
if (options.percant) rd += charAttributeAsInt(target, 'RD_percant', 0);
if (options.contondant) rd += charAttributeAsInt(target, 'RD_contondant', 0);
if (options.distance) {
var piqures = charAttributeAsInt(target, 'piquresDInsectes', 0);
if (piqures > 0 && ficheAttributeAsBool(target, 'DEFARMUREON') && ficheAttributeAsInt(target, 'DEFARMURE', 0) > 5) rd += piqures;
}
if (attributeAsBool(target, 'masqueMortuaire')) rd += 2;
var rdNature = charAttributeAsInt(target, 'RD_nature', 0);
if (rdNature > 0 && dmgNaturel(options)) rd += rdNature;
if (target.defautCuirasse) rd = 0;
if (options.intercepter) rd += options.intercepter;
if (target.extraRD) {
rd += target.extraRD;
expliquer(target.tokName + " dévie le coup sur son armure");
}
if (target.ignoreRD) rd = 0;
else if (target.ignoreMoitieRD) rd = parseInt(rd / 2);
if (rd > 0) {
if (showTotal) dmgDisplay = "(" + dmgDisplay + ") - " + rd;
else {
dmgDisplay += " - " + rd;
showTotal = true;
}
}
dmgTotal -= rd;
for (var dmSuiviType in dmSuivis) {
if (rd === 0) break;
dmSuivis[dmSuiviType] -= rd;
if (dmSuivis[dmSuiviType] < 0) {
rd = -dmSuivis[dmSuiviType];
dmSuivis[dmSuiviType] = 0;
} else rd = 0;
}
if (options.metal && attributeAsBool(target, 'magnetisme')) {
if (showTotal) dmgDisplay = "(" + dmgDisplay + ") / 2";
else dmgDisplay += " / 2";
showTotal = true;
dmgTotal = Math.ceil(dmgTotal / 2);
if (options.memePasMal)
options.memePasMal = Math.ceil(options.memePasMal / 2);
for (var dmType2 in dmSuivis) {
dmSuivis[dmType2] = Math.ceil(dmSuivis[dmType2] / 2);
}
}
if (dmgTotal < stateCOF.options.regles.val.dm_minimum.val) {
dmgTotal = stateCOF.options.regles.val.dm_minimum.val;
dmgDisplay += "-> " + stateCOF.options.regles.val.dm_minimum.val;
}
if (options.divise) {
dmgTotal = Math.ceil(dmgTotal / options.divise);
if (options.memePasMal)
options.memePasMal = Math.ceil(options.memePasMal / options.divise);
for (var dmType3 in dmSuivis) {
dmSuivis[dmType3] = Math.ceil(dmSuivis[dmType3] / options.divise);
}
dmgDisplay = "(" + dmgDisplay + ")/" + options.divise;
showTotal = true;
}
if (crit && options.memePasMal && options.memePasMal > 0) {
dmgTotal -= options.memePasMal;
if (dmgTotal < 0) {
options.memePasMal += dmgTotal;
dmgTotal = 0;
}
expliquer("Même pas mal : ignore " + options.memePasMal + " PVs et peut enrager");
var mpm = attributeAsInt(target, 'memePasMalIgnore', 0);
setTokenAttr(target, 'memePasMalIgnore', mpm + options.memePasMal, evt);
setTokenAttr(target, 'memePasMalBonus', 3, evt, undefined, getInit());
}
// compute effect on target
var bar1 = parseInt(token.get('bar1_value'));
var pvmax = parseInt(token.get('bar1_max'));
if (isNaN(bar1)) {
error("Pas de points de vie chez la cible", token);
bar1 = 0;
pvmax = 0;
} else if (isNaN(pvmax)) {
pvmax = bar1;
token.set("bar1_max", bar1);
}
var hasMana = (ficheAttributeAsInt(target, 'PM', 0) > 0);
var tempDmg = 0;
if (hasMana) {
tempDmg = attributeAsInt(target, 'DMTEMP', 0);
} else {
tempDmg = parseInt(token.get("bar2_value"));
if (isNaN(tempDmg)) {
if (target.tempDmg) { //then try to set bar2 correctly
if (token.get("bar1_link") === '') {
token.set("bar2_max", pvmax);
} else {
var tmpHitAttr =
findObjs({
_type: "attribute",
_characterid: charId,
name: "DMTEMP"
});
var dmTemp;
if (tmpHitAttr.length === 0) {
dmTemp =
createObj("attribute", {
characterid: charId,
name: "DMTEMP",
current: 0,
max: pvmax
});
} else {
dmTemp = tmpHitAttr[0];
}
token.set("bar2_max", pvmax);
token.set("bar2_link", dmTemp.id);
}
}
tempDmg = 0;
}
}
if (!options.aoe && charAttributeAsBool(target, 'ciblesMultiples')) {
dmgTotal = 1;
expliquer("La nuée est constituée de très nombreuses cibles, l'attaque ne lui fait qu'1 DM");
}
var pvPerdus = dmgTotal;
if (target.tempDmg) {
var oldTempDmg = tempDmg;
tempDmg += dmgTotal;
if (tempDmg > pvmax) {
pvPerdus -= tempDmg - pvmax;
tempDmg = pvmax;
}
if (hasMana) {
setTokenAttr(target, 'DMTEMP', tempDmg, evt);
} else {
updateCurrentBar(token, 2, tempDmg, evt);
}
enlevePVStatueDeBois(target, pvPerdus, evt);
} else {
if (bar1 > 0 && bar1 <= dmgTotal &&
charAttributeAsBool(target, 'instinctDeSurvieHumain')) {
dmgTotal = Math.floor(dmgTotal / 2);
for (var dmType4 in dmSuivis) {
dmSuivis[dmType4] = Math.floor(dmSuivis[dmType4] / 2);
}
if (dmgTotal < 1) dmgTotal = 1;
dmgDisplay += "/2";
showTotal = true;
expliquer("L'instinct de survie aide à réduire une attaque fatale");
}
pvPerdus = dmgTotal;
bar1 = bar1 - dmgTotal;
if (crit) { //Vulnérabilité aux critiues
var vulnerableCritique = charAttributeAsInt(target, 'vulnerableCritique', 0);
if (vulnerableCritique > 0) {
if (randomInteger(100) <= vulnerableCritique) {
expliquer("Le coup critique le fait voler en éclats");
if (bar1 > 0) {
dmgTotal += bar1;
pvPerdus += bar1;
bar1 = 0;
}
} else {
expliquer("Le coup critique fait vibrer l'adversaire, mais il résiste.");
}
}
}
if ((crit || bar1 < pvmax / 2) &&
charAttributeAsBool(target, 'peutEnrager') &&
!attributeAsBool(target, 'enragé')) {
setTokenAttr(target, 'enragé', true, evt);
expliquer(target.tokName + " devient enragé" + eForFemale(target.charId) + ".");
finDEffetDeNom(target, 'peur', evt);
finDEffetDeNom(target, 'peurEtourdi', evt);
setState(target, 'apeure', false, evt);
}
if (bar1 <= 0) {
var attrFDA = tokenAttribute(target, 'formeDArbre');
if (attrFDA.length > 0) {
var effetFDA = finDEffet(attrFDA[0], 'formeDArbre', attrFDA[0].get('name'), charId, evt, {
pageId: token.get('pageid')
});
if (effetFDA && effetFDA.newToken) {
token = effetFDA.newToken;
target.token = token;
}
var newBar1 = parseInt(token.get('bar1_value'));
if (isNaN(newBar1) || newBar1 < 0) {
error("Points de vie de l'ancien token incorrects", newBar1);
} else {
bar1 += newBar1;
}
}
}
//On enregistre les dm suivis
for (var dmType5 in dmSuivis) {
var d = dmSuivis[dmType5];
if (d) {
var attrDmSuivi = tokenAttribute(target, 'DMSuivis' + dmType5);
if (attrDmSuivi.length > 0) {
var cd = parseInt(attrDmSuivi[0].get('current'));
if (cd > 0) d += cd;
attrDmSuivi[0].set('current', d);
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attrDmSuivi[0],
current: cd
});
} else {
setTokenAttr(target, 'DMSuivis' + dmType5, d, evt);
}
}
}
if (bar1 <= 0) {
if (charAttributeAsBool(target, 'sergent') &&
!attributeAsBool(target, 'sergentUtilise')) {
expliquer(token.get('name') + " évite l'attaque in-extremis");
setTokenAttr(target, 'sergentUtilise', true, evt);
pvPerdus = 0;
} else {
testBlessureGrave(target, dmgTotal, expliquer, evt);
updateCurrentBar(token, 1, 0, evt);
pvPerdus += bar1;
if (charAttributeAsBool(target, 'baroudHonneur')) {
expliquer(token.get('name') + " devrait être mort, mais il continue à se battre !");
setTokenAttr(target, 'baroudHonneurActif', true, evt);
} else if (attributeAsBool(target, 'enragé')) {
if (!attributeAsBool(target, 'agitAZeroPV')) {
expliquer(token.get('name') + " devrait être mort, mais il continue à se battre !");
setTokenAttr(target, 'agitAZeroPV', 1, evt, undefined, getInit());
}
} else {
var defierLaMort = charAttributeAsInt(target, 'defierLaMort', 0);
if (defierLaMort > 0) {
save({
carac: 'CON',
seuil: defierLaMort
}, target, expliquer, {
msgPour: " pour défier la mort",
msgReussite: ", conserve 1 PV"
}, evt,
function(reussite, rollText) {
if (reussite) {
updateCurrentBar(token, 1, 1, evt);
bar1 = 1;
pvPerdus--;
setTokenAttr(target, 'defierLaMort', defierLaMort + 10, evt);
enlevePVStatueDeBois(target, pvPerdus, evt);
} else {
mort(target, expliquer, evt);
testBlessureGrave(target, 'mort', expliquer, evt);
}
if (bar1 > 0 && tempDmg >= bar1) { //assomé
setState(target, 'assome', true, evt);
}
if (showTotal) dmgDisplay += " = " + dmgTotal;
if (displayRes === undefined) return dmgDisplay;
displayRes(dmgDisplay, pvPerdus);
});
if (displayRes === undefined) return dmgDisplay;
return;
} else {
mort(target, expliquer, evt);
testBlessureGrave(target, 'mort', expliquer, evt);
}
}
}
} else { // bar1>0
testBlessureGrave(target, dmgTotal, expliquer, evt);
updateCurrentBar(token, 1, bar1, evt);
enlevePVStatueDeBois(target, pvPerdus, evt);
}
}
if (bar1 > 0 && tempDmg >= bar1) { //assomé
setState(target, 'assome', true, evt);
}
if (showTotal) dmgDisplay += " = " + dmgTotal;
if (displayRes === undefined) return dmgDisplay;
displayRes(dmgDisplay, pvPerdus);
});
return dmgDisplay;
}
function buildinline(inlineroll, dmgType, magique) {
var InlineColorOverride = "";
var values = [];
var critRoll = false;
var failRoll = false;
var critCheck = false;
var failCheck = false;
var highRoll = false;
var lowRoll = false;
var noHighlight = false;
inlineroll.results.rolls.forEach(function(roll) {
var result = processRoll(roll, critRoll, failRoll, highRoll, lowRoll, noHighlight);
if (result.value.toString().indexOf("critsuccess") != -1) critCheck = true;
if (result.value.toString().indexOf("critfail") != -1) failCheck = true;
values.push(result.value);
critRoll = result.critRoll;
failRoll = result.failRoll;
highRoll = result.highRoll;
lowRoll = result.lowRoll;
noHighlight = result.noHighlight;
});
// Overrides the default coloring of the inline rolls...
switch (dmgType) {
case 'normal':
case 'maladie':
if (magique)
InlineColorOverride = ' background-color: #FFFFFF; color: #534200;';
else
InlineColorOverride = ' background-color: #F1E6DA; color: #000;';
break;
case 'feu':
InlineColorOverride = ' background-color: #FF3011; color: #440000;';
break;
case 'froid':
InlineColorOverride = ' background-color: #77FFFF; color: #004444;';
break;
case 'acide':
InlineColorOverride = ' background-color: #80BF40; color: #020401;';
break;
case 'sonique':
InlineColorOverride = ' background-color: #E6CCFF; color: #001144;';
break;
case 'electrique':
InlineColorOverride = ' background-color: #FFFF80; color: #222200;';
break;
case 'poison':
InlineColorOverride = ' background-color: #558000; color: #DDAFFF;';
break;
case 'argent':
InlineColorOverride = ' background-color: #F1E6DA; color: #C0C0C0;';
break;
default:
if (critCheck && failCheck) {
InlineColorOverride = ' background-color: #8FA4D4; color: #061539;';
} else if (critCheck && !failCheck) {
InlineColorOverride = ' background-color: #88CC88; color: #004400;';
} else if (!critCheck && failCheck) {
InlineColorOverride = ' background-color: #FFAAAA; color: #660000;';
} else {
InlineColorOverride = ' background-color: #FFFEA2; color: #000;';
}
}
var rollOut = '<span style="display: inline-block; border-radius: 5px; padding: 0 4px; ' + InlineColorOverride + '" title="' + inlineroll.expression + ' = ' + values.join("");
rollOut += '" class="a inlinerollresult showtip tipsy-n';
rollOut += (critCheck && failCheck) ? ' importantroll' : (critCheck ? ' fullcrit' : (failCheck ? ' fullfail' : ''));
rollOut += '">' + inlineroll.results.total + '</span>';
return rollOut;
}
function processRoll(roll, critRoll, failRoll, highRoll, lowRoll, noHighlight) {
switch (roll.type) {
case 'C':
return {
value: " " + roll.text + " "
};
case 'L':
if (roll.text.indexOf("HR") != -1) highRoll = parseInt(roll.text.substring(2));
else highRoll = false;
if (roll.text.indexOf("LR") != -1) lowRoll = parseInt(roll.text.substring(2));
else lowRoll = false;
if (roll.text.indexOf("NH") != -1) {
// Blocks highlight on an individual roll...
noHighlight = true;
}
// Remove inline tags to reduce clutter...
roll.text = roll.text.replace(/HR(\d+)/g, "");
roll.text = roll.text.replace(/LR(\d+)/g, "");
roll.text = roll.text.replace(/NH/g, "");
if (roll.text !== "") roll.text = " [" + roll.text + "] ";
return {
value: roll.text,
highRoll: highRoll,
lowRoll: lowRoll,
noHighlight: noHighlight
};
case 'M':
roll.expr = roll.expr.toString().replace(/\+/g, " + ");
return {
value: roll.expr
};
case 'R':
var rollValues = [];
roll.results.forEach(function(result) {
if (result.tableItem !== undefined) {
rollValues.push(result.tableItem.name);
} else {
// Turn off highlighting if true...
if (noHighlight) {
critRoll = false;
failRoll = false;
} else {
if (_.has(roll, 'mods') && _.has(roll.mods, 'customCrit')) {
switch (roll.mods.customCrit[0].comp) {
case '=':
case '==':
critRoll = (result.v == roll.mods.customCrit[0].point);
break;
case '>=':
case '=>':
case '>':
critRoll = (result.v >= roll.mods.customCrit[0].point);
break;
default:
critRoll =
(highRoll !== false && result.v >= highRoll ||
result.v === roll.sides);
}
} else {
critRoll =
(highRoll !== false && result.v >= highRoll ||
result.v === roll.sides);
}
failRoll =
(!critRoll &&
(lowRoll !== false && result.v <= lowRoll || result.v === 1));
}
var rv = "<span class='basicdiceroll" + (critRoll ? ' critsuccess' : (failRoll ? ' critfail' : '')) + "'>" + result.v + "</span>";
rollValues.push(rv);
}
});
var separator = ' + ';
if (roll.mods && roll.mods.keep) separator = ' , ';
return {
value: "(" + rollValues.join(separator) + ")",
critRoll: critRoll,
failRoll: failRoll,
highRoll: highRoll,
lowRoll: lowRoll,
noHighlight: noHighlight
};
case 'G':
var grollVal = [];
roll.rolls.forEach(function(groll) {
groll.forEach(function(groll2) {
var result = processRoll(groll2, highRoll, lowRoll, noHighlight);
grollVal.push(result.value);
critRoll = critRoll || result.critRoll;
failRoll = failRoll || result.failRoll;
highRoll = highRoll || result.highRoll;
lowRoll = lowRoll || result.lowRoll;
noHighlight = noHighlight || result.noHighlight;
});
});
return {
value: "{" + grollVal.join(" ") + "}",
critRoll: critRoll,
failRoll: failRoll,
highRoll: highRoll,
lowRoll: lowRoll,
noHighlight: noHighlight
};
}
}
function getBrightness(hex) {
hex = hex.replace('#', '');
var c_r = hexDec(hex.substr(0, 2));
var c_g = hexDec(hex.substr(2, 2));
var c_b = hexDec(hex.substr(4, 2));
return ((c_r * 299) + (c_g * 587) + (c_b * 114)) / 1000;
}
function hexDec(hex_string) {
hex_string = (hex_string + '').replace(/[^a-f0-9]/gi, '');
return parseInt(hex_string, 16);
}
function addOrigin(name, toEvaluate) {
return toEvaluate.replace(/@{/g, "@{" + name + "|");
}
function getPortee(charId, weaponPrefix) {
var res = getAttrByName(charId, weaponPrefix + "armeportee");
if (res === undefined) return 0;
res = parseInt(res);
if (isNaN(res) || res <= 0) return 0;
return res;
}
function tokenCenter(tok) {
return [tok.get('left'), tok.get('top')];
}
// Retourne le diamètre d'un disque inscrit dans un carré de surface
// équivalente à celle du token
function tokenSizeAsCircle(token) {
var surface = token.get('width') * token.get('height');
return Math.sqrt(surface);
}
// if token is bigger than thresh reduce the distance by that size
function tokenSize(tok, thresh) {
var size = (tok.get('width') + tok.get('height')) / 2;
if (size > thresh) return ((size - thresh) / 2);
return 0;
}
function malusDistance(perso1, tok2, distance, portee, pageId, explications, ignoreObstacles) {
if (distance === 0) return 0;
var tok1 = perso1.token;
var mPortee = (distance <= portee) ? 0 : (Math.ceil(5 * (distance - portee) / portee));
if (mPortee > 0) {
explications.push("Distance > " + portee + " m => -" + mPortee + " en Attaque");
}
if (ignoreObstacles || charAttributeAsBool(perso1, 'joliCoup'))
return mPortee;
// Now determine if any token is between tok1 and tok2
var allToks =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
var mObstacle = 0;
var pt1 = tokenCenter(tok1);
var pt2 = tokenCenter(tok2);
var distance_pix = VecMath.length(VecMath.vec(pt1, pt2));
var liste_obstacles = [];
allToks.forEach(function(obj) {
if (obj.id == tok1.id || obj.id == tok2.id) return;
var objCharId = obj.get('represents');
var perso = {
token: obj,
charId: objCharId
};
if (objCharId !== '' && (getState(perso, 'mort') ||
getState(perso, 'assome') || getState(perso, 'endormi') ||
attributeAsBool(perso, 'intangible')))
return;
//On regarde si le token est une monture d'un des personnages
var attrMonte = tokenAttribute(perso, 'estMontePar');
var estMonture = attrMonte.find(function(a) {
var cid = a.get('current');
return cid == tok1.id || cid == tok2.id;
});
if (estMonture) return;
var pt = tokenCenter(obj);
var obj_dist = VecMath.length(VecMath.vec(pt1, pt));
if (obj_dist > distance_pix) return;
obj_dist = VecMath.length(VecMath.vec(pt2, pt));
if (obj_dist > distance_pix) return;
var distToTrajectory = VecMath.ptSegDist(pt, pt1, pt2);
// On modélise le token comme un disque
var rayonObj = tokenSizeAsCircle(obj) / 2;
if (distToTrajectory > rayonObj) return;
liste_obstacles.push(obj.get("name"));
// On calcule un malus proportionnel à l'arc à traverser
// Pour l'instant, malus = 1 si distance = PIX_PER_UNIT
var longueurArc = 2 * Math.sqrt(rayonObj * rayonObj - distToTrajectory * distToTrajectory);
var mToken = longueurArc / PIX_PER_UNIT;
//malus plus important si l'obstacle est au contact de la cible
if (distanceCombat(tok2, obj, pageId) === 0) mToken *= 5;
else mToken *= 3;
mObstacle += mToken;
});
// On ajuste aussi en fonction de la taille de la cible
mObstacle = mObstacle / (tokenSizeAsCircle(tok2) / PIX_PER_UNIT);
if (mObstacle > 5) mObstacle = 5;
else mObstacle = Math.round(mObstacle);
var res = mPortee + mObstacle;
if (mObstacle > 0) {
log("Obstacle" + ((mObstacle > 1) ? "s" : "") + " trouvé : " + liste_obstacles.join(', '));
explications.push('Obstacle' + ((mObstacle > 1) ? 's' : '') + ' sur le trajet => -' + mObstacle + ' en Attaque<br /><span style="font-size: 0.8em; color: #666;">' + liste_obstacles.join(', ') + '</span>');
}
return res;
}
// Returns all attributes in attrs, with name name or starting with name_
function allAttributesNamed(attrs, name) {
var reg = new RegExp("^" + name + "($|_|\\()");
return attrs.filter(function(obj) {
var attrName = obj.get('name');
return reg.test(attrName);
});
}
//Met tous les attributs avec le nom au max
function resetAttr(attrs, attrName, evt, msg) {
allAttributesNamed(attrs, attrName).forEach(function(att) {
var vm = parseInt(att.get("max"));
if (!isNaN(vm)) {
var vc = parseInt(att.get("current"));
if (vc != vm) {
evt.attributes.push({
attribute: att,
current: vc
});
att.set("current", vm);
if (msg) {
var charId = att.get('characterid');
var character = getObj('character', charId);
var name = character.get('name');
sendChar(charId, '/w "' + name + '" ' + msg);
}
}
}
});
}
// Fait foo sur tous les tokens représentant charId, ayant l'effet donné, et correspondant au nom d'attribut. Pour le cas où le token doit être lié au personnage, on ne prend qu'un seul token, sauf si les options indiquent autrement (soit option.tousLesTokens, soit une fonction options.filterAffected)
// Ne fonctionne correctement que pour les attributs sans _
function iterTokensOfAttribute(charId, pageId, attrName, attrNameComplet, foo, options) {
options = options || {};
var total = 1; //Nombre de tokens affectés, pour gérer l'asynchronie si besoin
if (attrNameComplet == attrName) { //token lié au character
var tokens;
if (pageId) {
tokens =
findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
layer: 'objects',
represents: charId
});
}
if (tokens === undefined ||
(tokens.length === 0 && !options.onlyOnPage)) {
tokens =
findObjs({
_type: 'graphic',
_subtype: 'token',
layer: 'objects',
represents: charId
});
tokens = tokens.filter(function(tok) {
if (tok.get('bar1_link') === '') return false;
var pid = tok.get('pageid');
var page = getObj('page', pid);
if (page) {
return !(page.get('archived'));
}
return false;
});
}
if (tokens.length === 0) {
if (options.possiblementAbsent) return;
log("Pas de token pour un personnage");
log(charId);
log(attrNameComplet);
return;
}
if (options.tousLesTokens) {
tokens.forEach(function(tok) {
foo(tok, tokens.length);
});
} else if (options.filterAffected) {
total = tokens.length;
tokens.forEach(function(tok) {
if (options.filterAffected(tok)) foo(tok, total);
});
} else foo(tokens[0], 1);
} else { //token non lié au character
var tokenName = attrNameComplet.substring(attrNameComplet.indexOf('_') + 1);
var tNames;
if (pageId) {
tNames =
findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
layer: 'objects',
represents: charId,
name: tokenName,
bar1_link: ''
});
}
if (tNames === undefined || (tNames.length === 0 && !options.onlyOnPage)) {
tNames =
findObjs({
_type: 'graphic',
_subtype: 'token',
represents: charId,
name: tokenName,
layer: 'objects',
bar1_link: ''
});
tNames = tNames.filter(function(tok) {
var pid = tok.get('pageid');
var page = getObj('page', pid);
if (page) {
return !(page.get('archived'));
}
return false;
});
}
total = tNames.length;
if (total > 1) {
var character = getObj('character', charId);
var charName = "d'id " + charId;
if (character) charName = character.get('name');
error("Attention, il y a plusieurs tokens nommés " + tokenName + ", instances du personnage " + charName, total);
}
tNames.forEach(function(tok) {
foo(tok, total);
});
}
}
function sortirDuCombat() {
if (!stateCOF.combat) {
log("Pas en combat");
sendChat("GM", "/w GM Le combat est déjà terminé");
return;
}
sendChat("GM", "Le combat est terminé");
var evt = {
type: 'fin_combat',
initiativepage: Campaign().get('initiativepage'),
turnorder: Campaign().get('turnorder'),
attributes: [],
combat: true,
tour: stateCOF.tour,
init: stateCOF.init,
deletedAttributes: []
};
stateCOF.combat = false;
setActiveToken(undefined, evt);
Campaign().set('initiativepage', false);
var attrs = findObjs({
_type: 'attribute'
});
// Fin des effets qui durent pour le combat
attrs = removeAllAttributes('soinsDeGroupe', evt, attrs);
attrs = removeAllAttributes('secondSouffle', evt, attrs);
attrs = removeAllAttributes('sergentUtilise', evt, attrs);
attrs = removeAllAttributes('enflamme', evt, attrs);
attrs = removeAllAttributes('protegerUnAllie', evt, attrs);
attrs = removeAllAttributes('protegePar', evt, attrs);
attrs = removeAllAttributes('intercepter', evt, attrs);
attrs = removeAllAttributes('interposer', evt, attrs);
attrs = removeAllAttributes('defenseTotale', evt, attrs);
attrs = removeAllAttributes('dureeStrangulation', evt, attrs);
attrs = removeAllAttributes('defautDansLaCuirasse', evt, attrs);
attrs = removeAllAttributes('postureDeCombat', evt, attrs);
attrs = removeAllAttributes('dedouble', evt, attrs);
attrs = removeAllAttributes('limiteParCombat', evt, attrs);
attrs = removeAllAttributes('armeSecreteBardeUtilisee', evt, attrs);
attrs = removeAllAttributes('attaqueMalgreMenace', evt, attrs);
attrs = removeAllAttributes('limiteApplicationManoeuvre', evt, attrs);
attrs = removeAllAttributes('attaqueParMeute', evt, attrs);
// Autres attributs
// Remettre le pacifisme au max
resetAttr(attrs, 'pacifisme', evt, "retrouve son pacifisme");
// Remettre le traquenard à 1
resetAttr(attrs, 'traquenard', evt);
// Tout le monde recharge ses armes après un combat, non ?
resetAttr(attrs, 'charge', evt, "recharge ses armes");
// Et on récupère les munitions récupérables
resetAttr(attrs, 'munition', evt, "récupère ses munitions");
// Remettre défier la mort à 10
resetAttr(attrs, 'defierLaMort', evt);
// Recharger les runes d'énergie
resetAttr(attrs, 'runeDEnergie', evt);
resetAttr(attrs, 'runeDeProtection', evt);
resetAttr(attrs, 'runeDePuissance', evt);
// Remettre l'esquive fatale à 1
resetAttr(attrs, 'esquiveFatale', evt);
resetAttr(attrs, 'attaqueEnTraitre', evt);
resetAttr(attrs, 'esquiveAcrobatique', evt);
// Réinitialiser le kiai
resetAttr(attrs, 'kiai', evt);
// On diminue l'ébriété des personnages sous vapeurs éthyliques
allAttributesNamed(attrs, 'vapeursEthyliques').forEach(function(attr) {
var veCharId = attr.get('characterid');
if (veCharId === undefined || veCharId === '') {
error("Attribut sans personnage associé", attr);
return;
}
iterTokensOfAttribute(veCharId, stateCOF.combat_pageid,
'vapeursEthyliques', attr.get('name'),
function(tok) {
var perso = {
charId: veCharId,
token: tok
};
removeTokenAttr(perso, 'niveauEbriete', evt, "désaoûle");
});
});
attrs = removeAllAttributes('vapeursEthyliques', evt, attrs);
// Pour frappe du vide, on rengaine l'arme, cela remet aussi l'attribut
allAttributesNamed(attrs, 'frappeDuVide').forEach(function(attr) {
var fdvCharId = attr.get('characterid');
if (fdvCharId === undefined || fdvCharId === '') {
error("Attribut sans personnage associé", attr);
return;
}
iterTokensOfAttribute(fdvCharId, stateCOF.combat_pageid,
'frappeDuVide', attr.get('name'),
function(tok) {
var perso = {
charId: fdvCharId,
token: tok
};
degainerArme(perso, '', evt);
});
});
// On remet en main l'arme par défaut si elle est précisée
allAttributesNamed(attrs, 'armeParDefaut').forEach(function(attr) {
var apdCharId = attr.get('characterid');
if (apdCharId === undefined || apdCharId === '') {
error("Attribut sans personnage associé", attr);
return;
}
iterTokensOfAttribute(apdCharId, stateCOF.combat_pageid,
'armeParDefaut', attr.get('name'),
function(tok) {
var perso = {
charId: apdCharId,
token: tok
};
degainerArme(perso, attr.get('current'), evt);
});
});
//Effet de ignorerLaDouleur
var ilds = allAttributesNamed(attrs, 'ignorerLaDouleur');
ilds = ilds.concat(allAttributesNamed(attrs, 'memePasMalIgnore'));
ilds.forEach(function(ild) {
var douleur = parseInt(ild.get('current'));
if (isNaN(douleur)) {
error("La douleur ignorée n'est pas un nombre", douleur);
return;
}
var charId = ild.get('characterid');
if (charId === undefined || charId === '') {
error("Attribut sans personnage", ild);
return;
}
var ildName = ild.get('name');
if (ildName == 'ignorerLaDouleur' || ildName == 'memePasMalIgnore') {
var pvAttr = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'PV'
}, {
caseInsensitive: true
});
if (getAttrByName(charId, 'type_personnage') == 'PNJ') {
pvAttr = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'pnj_pv'
}, {
caseInsensitive: true
});
}
if (pvAttr.length === 0) {
error("Personnage sans PV ", charId);
return;
}
pvAttr = pvAttr[0];
var pv = parseInt(pvAttr.get('current'));
if (isNaN(pv)) {
error("PV mal formés ", pvAttr);
return;
}
evt.attributes.push({
attribute: pvAttr,
current: pv
});
var newPv = pv - douleur;
if (newPv < 0) newPv = 0;
pvAttr.set('current', newPv);
if (pv > 0 && newPv === 0) {
sendChar(charId, "s'écroule. Il semble sans vie. La douleur qu'il avait ignorée l'a finalement rattrapé...");
} else {
var tempDmg = attributeAsInt(charId, 'DMTEMP', 0);
if (pv > tempDmg && newPv <= tempDmg) {
sendChar(charId, "s'écroule, assomé. La douleur qu'il avait ignorée l'a finalement rattrapé...");
} else {
sendChar(charId, "subit le contrecoup de la douleur qu'il avait ignorée");
}
}
} else { // ignorer la douleur d'un token
var tokName = ildName.substring(ildName.indexOf('_') + 1);
var tokensIld = findObjs({
_type: 'graphic',
_subtype: 'token',
represents: charId,
name: tokName
});
if (tokensIld.length === 0) {
error("Pas de token nommé " + tokName + " qui aurait ignoré la douleur", ild);
return;
}
if (tokensIld.length > 1) {
sendChar(charId, "a plusieurs tokens nommés " + tokName + ". Un seul d'entre eux subira l'effet d'ignorer la douleur");
}
var tokPv = parseInt(tokensIld[0].get('bar1_value'));
var tokNewPv = tokPv - douleur;
if (tokNewPv < 0) tokNewPv = 0;
updateCurrentBar(tokensIld[0], 1, tokNewPv, evt);
//TODO: faire mourrir, assomer
}
}); // end forEach on all attributes ignorerLaDouleur
ilds.forEach(function(ild) {
evt.deletedAttributes.push(ild);
ild.remove();
});
if (ilds.length > 0) {
attrs = attrs.filter(function(attr) {
var ind = ilds.findIndex(function(nattr) {
return nattr.id == attr.id;
});
return (ind == -1);
});
}
// fin des effets temporaires (durée en tours, ou durée = combat)
attrs.forEach(function(obj) {
var attrName = obj.get('name');
var charId = obj.get('characterid');
if (estEffetTemp(attrName)) {
finDEffet(obj, effetTempOfAttribute(obj), attrName, charId, evt, {
gardeAutresAttributs: true,
// pageId: stateCOF.combat_pageid //l'id pourrait avoir changé
});
} else if (estAttributEffetTemp(attrName)) {
evt.deletedAttributes.push(obj);
obj.remove();
} else if (estEffetCombat(attrName)) {
var mc = messageEffetCombat[effetCombatOfAttribute(obj)].fin;
if (mc && mc !== '') sendChar(charId, mc);
evt.deletedAttributes.push(obj);
obj.remove();
} else if (estAttributEffetCombat(attrName)) {
evt.deletedAttributes.push(obj);
obj.remove();
}
});
addEvent(evt);
}
function pointsDeRecuperation(perso) {
// retourne les nombre de PR restant
var attrPR = tokenAttribute(perso, 'pointsDeRecuperation');
if (attrPR.length > 0) {
var prc = parseInt(attrPR[0].get('current'));
var prm = parseInt(attrPR[0].get('max'));
return {
current: prc,
max: prm
};
}
var pr = 5;
var x;
for (var i = 1; i < 6; i++) {
x = getAttrByName(perso.charId, "PR" + i);
if (x == 1) pr--;
}
return {
current: pr,
max: 5
};
}
function enleverPointDeRecuperation(perso, evt) {
var attrPR = tokenAttribute(perso, 'pointsDeRecuperation');
if (attrPR.length > 0) {
var prc = parseInt(attrPR[0].get('current'));
if (prc > 0) {
setTokenAttr(perso, 'pointsDeRecuperation', prc - 1, evt);
return;
}
sendChat("COF", "Plus de point de récupération à enlever");
return;
}
evt.attributes = evt.attributes || [];
for (var i = 1; i < 6; i++) {
var prAttr = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: "PR" + i
});
if (prAttr.length === 0) {
prAttr = createObj("attribute", {
characterid: perso.charId,
name: "PR" + i,
current: 1,
max: 1
});
evt.attributes.push({
attribute: prAttr,
current: null
});
return;
} else if (prAttr[0].get('current') == 0) { // jshint ignore:line
prAttr[0].set("current", 1);
evt.attributes.push({
attribute: prAttr[0],
current: 0
});
return;
}
}
sendChat("COF", "Plus de point de récupération à enlever");
}
function rajouterPointDeRecuperation(perso, evt) {
var attrPR = tokenAttribute(perso, 'pointsDeRecuperation');
if (attrPR.length > 0) {
var prc = parseInt(attrPR[0].get('current'));
var prmax = parseInt(attrPR[0].get('max'));
if (prc < prmax) {
setTokenAttr(perso, 'pointsDeRecuperation', prc + 1, evt);
return true;
}
log("Pas de point de récupération à récupérer pour " + perso.token.get('name'));
return;
}
for (var i = 1; i < 6; i++) {
var prAttr =
findObjs({
_type: "attribute",
_characterid: perso.charId,
name: "PR" + i
});
if (prAttr.length > 0 && prAttr[0].get("current") == 1) {
prAttr[0].set("current", 0);
evt.attributes.push({
attribute: prAttr[0],
current: 1
});
return true;
}
}
log("Pas de point de récupération à récupérer pour " + perso.token.get('name'));
}
//Asynchrone
function soinsEcuyers(ecuyers, manquePV, playerId, evt) {
var count = ecuyers.length;
var finalize = function() {
count--;
if (count === 0) {
addEvent(evt);
}
};
ecuyers.forEach(function(ec) {
var ecuyer = ec.perso;
var ecuyerDe = ec.ecuyerDe;
var charChevalier = findObjs({
_type: 'character',
name: ecuyerDe
});
if (charChevalier.length === 0) {
error("Pas de chevalier " + ecuyerDe + " pour l'écuyer " + ecuyer.token.get('name'), ec);
finalize();
return;
}
if (charChevalier.length > 1) {
error("Plusieurs personnages nommés " + ecuyerDe + ". Attention aux ambiguités.");
}
charChevalier = charChevalier[0].id;
var maxASoigner = modCarac(charChevalier, 'CHARISME') + 1;
var allies = alliesParPerso[ecuyer.charId] || new Set();
var alliesASoigner = [];
var nbCibles = 0;
var chevalier;
var monture;
manquePV.forEach(function(cible) {
if (cible.charId == charChevalier) {
chevalier = cible;
nbCibles++;
return;
}
if (allies.has(cible.charId)) {
var montureDe = findObjs({
_type: 'attribute',
_characterid: cible.charId,
name: 'montureDe'
});
if (montureDe.length > 0 && montureDe[0].get('current') == ecuyerDe) {
monture = cible;
nbCibles++;
return;
}
alliesASoigner.push(cible);
}
}); //fin de détermination des cibles
if (chevalier === undefined && monture === undefined &&
(maxASoigner < 1 || alliesASoigner.length === 0)) { //Personne à soigner
finalize();
return;
}
//TODO: utiliser l'id d'un player qui contrôle le chevalier
var display = startFramedDisplay(playerId, "Services d'écuyer", ecuyer);
var finSoin = function() {
nbCibles--;
if (nbCibles === 0) {
if (display) sendChat("", endFramedDisplay(display));
finalize();
}
};
var soigneUneCible = function(c) {
sendChat('', "[[2d6]]", function(res) {
var soins = res[0].inlinerolls[0].results.total;
var soinTxt = buildinline(res[0].inlinerolls[0], 'normal', true);
var printTrue = function(s) {
var msgSoin = ecuyer.token.get('name') + ' ';
if (c.id == ecuyer.token.id) {
msgSoin = 'se soigne de ';
} else {
msgSoin = c.token.get('name') + " récupère ";
}
if (s < soins)
msgSoin += s + " PV. (Le résultat du jet était " + soinTxt + ")";
else msgSoin += soinTxt + " PV.";
addLineToFramedDisplay(display, msgSoin);
};
soigneToken(c, soins, evt, printTrue);
finSoin();
}); //fin du sendChar
}; // fin de définition de soigneCible
var peutToutSoigner = (alliesASoigner.length <= maxASoigner);
if (peutToutSoigner) nbCibles += alliesASoigner.length;
else if (maxASoigner > 0) nbCibles++; //pour ne pas finir avant d'imprimer les boutons
if (chevalier) soigneUneCible(chevalier);
if (monture) soigneUneCible(monture);
if (peutToutSoigner) {
alliesASoigner.forEach(soigneUneCible);
} else if (maxASoigner > 0) {
addLineToFramedDisplay(display, "Peut prendre soin de (max " + maxASoigner + ") :");
var attr = setTokenAttr(ecuyer, 'SoinsdEcuyer', maxASoigner, evt);
var action = "!cof-soin " + ecuyer.token.id + " ";
alliesASoigner.forEach(function(c) {
var nom = c.token.get('name');
addLineToFramedDisplay(display, bouton(action + c.token.id + " 2d6", nom, ecuyer, attr));
});
finSoin();
}
}); //fin iteration sur les écuyers
}
// Récupération pour tous les tokens sélectionnés
function nuit(msg, evt) {
if (stateCOF.combat) sortirDuCombat();
getSelected(msg, function(selection, playerId) {
if (selection.length === 0) {
var pageId = getPageId(playerId);
var tokens =
findObjs({
_type: 'graphic',
_subtype: 'token',
layer: 'objects',
_pageid: pageId
});
tokens.forEach(function(tok) {
if (tok.get('represents') === '') return;
selection.push({
_id: tok.id
});
});
}
if (evt === undefined) evt = {
type: "Nuit",
attributes: []
};
if (msg.content.startsWith('!cof-nuit')) jour(evt);
recuperation(selection, true, playerId, evt);
});
}
// Remise à zéro de toutes les limites journalières
function jour(evt) {
var attrs;
attrs = removeAllAttributes('pressionMortelle', evt);
attrs = removeAllAttributes('soinsLegers', evt, attrs);
attrs = removeAllAttributes('soinsModeres', evt, attrs);
attrs = removeAllAttributes('fortifie', evt, attrs);
attrs = removeAllAttributes('limiteParJour', evt, attrs);
attrs = removeAllAttributes('tueurFantasmagorique', evt, attrs);
attrs = removeAllAttributes('resisteInjonction', evt, attrs);
//Les élixirs
var attrsElixirsACreer = attrs.filter(function(a) {
return a.get('name').startsWith('elixirsACreer');
});
attrs = removeAllAttributes('elixirsACreer', evt, attrs);
attrs = removeAllAttributes('elixir', evt, attrs);
//On pourrait diviser par 2 le nombre de baies
//var attrsBaie = allAttributesNamed(attrs, 'dose_baie_magique');
}
function nouveauJour(msg) {
var evt = {
type: "Nouveau jour",
attributes: []
};
var playerId = getPlayerIdFromMsg(msg);
var fromMsg = 'player|' + playerId;
var player = getObj('player', playerId);
if (player) {
var speaksAs = player.get('speakingas');
if (speaksAs !== '') fromMsg = speaksAs;
}
sendChat(fromMsg, "Un nouveau jour se lève");
jour(evt);
if (msg.content.includes(' --repos')) nuit(msg, evt);
else addEvent(evt);
}
function recuperer(msg) {
if (stateCOF.combat) {
sendPlayer(msg, "impossible de se reposer en combat");
return;
}
var reposLong = false;
if (msg.content.includes(' --reposLong')) reposLong = true;
getSelected(msg, function(selection, playerId) {
if (selection.length === 0) {
sendPlayer(msg, "!cof-recuperer sans sélection de tokens");
log("!cof-recuperer requiert des tokens sélectionnés");
return;
}
var evt = {
type: "Récuperation",
attributes: []
};
recuperation(selection, reposLong, playerId, evt);
});
}
//Asynchrone (jets de dés)
function recuperation(selection, reposLong, playerId, evt) {
var manquePV = [];
var ecuyers = [];
var count = selection.length;
var finalize = function() {
count--;
if (count === 0) {
if (ecuyers.length > 0 && manquePV.length > 0) {
soinsEcuyers(ecuyers, manquePV, playerId, evt);
} else addEvent(evt);
}
};
iterSelected(selection, function(perso) {
if (getState(perso, 'mort')) {
finalize();
return;
}
if (reposLong) {
var attrEcuyerDe = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: 'ecuyerDe'
});
if (attrEcuyerDe.length > 0) {
ecuyers.push({
perso: perso,
ecuyerDe: attrEcuyerDe[0].get('current')
});
}
}
var token = perso.token;
var charId = perso.charId;
var character = getObj("character", charId);
if (character === undefined) {
finalize();
return;
}
var characterName = character.get("name");
var pr = pointsDeRecuperation(perso);
var bar2 = parseInt(token.get("bar2_value"));
var manaAttr = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'PM'
}, {
caseInsensitive: true
});
var hasMana = false;
var dmTemp = bar2;
if (manaAttr.length > 0) { // Récupération des points de mana
var manaMax = parseInt(manaAttr[0].get('max'));
hasMana = !isNaN(manaMax) && manaMax > 0;
if (hasMana) {
dmTemp = attributeAsInt(perso, 'DMTEMP', 0);
if (reposLong && (isNaN(bar2) || bar2 < manaMax)) {
updateCurrentBar(token, 2, manaMax, evt);
}
}
}
if (!isNaN(dmTemp) && dmTemp > 0) { // récupération de DM temp
if (reposLong) dmTemp = 0;
else dmTemp = Math.max(0, dmTemp - 10);
if (hasMana) {
setTokenAttr(perso, 'DMTEMP', dmTemp, evt);
} else {
updateCurrentBar(token, 2, dmTemp, evt);
}
}
var bar1 = parseInt(token.get("bar1_value"));
var pvmax = parseInt(token.get("bar1_max"));
if (isNaN(bar1) || isNaN(pvmax)) return;
if (bar1 >= pvmax && (pr.current == pr.max || !reposLong)) {
if (!reposLong) {
sendChat("", characterName + " n'a pas besoin de repos");
}
finalize();
return;
}
if (reposLong && charAttributeAsBool(perso, 'montureMagique')) {
//La monture magique récupère tous ses PV durant la nuit
updateCurrentBar(token, 1, pvmax, evt);
sendChar(charId, "récupère tous ses PV");
finalize();
return;
}
var dVie = charAttributeAsInt(perso, "DV", 0);
if (dVie < 4) {
if (bar1 < pvmax) manquePV.push(perso);
finalize();
return; //Si pas de dé de vie, alors pas de PR.
}
var message;
if (reposLong && pr.current < pr.max) { // on récupère un PR
//Sauf si on a une blessure gave
if (getState(perso, 'blessé')) {
testCaracteristique(perso, 'CON', 8, {}, evt, function(tr) {
sendChar(charId, "fait un jet de CON pour guérir de sa blessure");
var m = "/direct " + onGenre(charId, 'Il', 'Elle') + " fait " + tr.texte;
if (tr.reussite) {
sendChar(charId, m + "≥ 8, son état s'améliore nettement.");
setState(perso, 'blessé', false, evt);
} else sendChar(charId, m + "< 8, son état reste préoccupant.");
finalize();
});
return;
}
var affAttr = rajouterPointDeRecuperation(perso, evt);
if (affAttr === undefined) {
error("Pas de point de récupérartion à rajouter et pourtant pas au max", token);
finalize();
return;
}
message =
"Au cours de la nuit, les points de récupération de " + characterName +
" passent de " + pr.current + " à " + (pr.current + 1);
sendChar(charId, message);
if (bar1 < pvmax) manquePV.push(perso);
finalize();
return;
}
if (!reposLong) {
if (pr.current === 0) { //pas possible de récupérer
message = " a besoin d'une nuit complète pour récupérer";
sendChar(charId, message);
finalize();
return;
} else { //dépense d'un PR
enleverPointDeRecuperation(perso, evt);
pr.current--;
}
}
var conMod = modCarac(perso, 'CONSTITUTION');
var niveau = ficheAttributeAsInt(perso, 'NIVEAU', 1);
var rollExpr = addOrigin(characterName, "[[1d" + dVie + "]]");
sendChat("COF", rollExpr, function(res) {
var rolls = res[0];
var dVieRoll = rolls.inlinerolls[0].results.total;
var bonus = conMod + niveau;
var total = dVieRoll + bonus;
if (total < 0) total = 0;
if (bar1 === 0) {
if (attributeAsBool(perso, 'etatExsangue')) {
removeTokenAttr(perso, 'etatExsangue', evt, "retrouve des couleurs");
}
}
bar1 += total;
if (bar1 < pvmax) manquePV.push(perso);
else bar1 = pvmax;
updateCurrentBar(token, 1, bar1, evt);
if (reposLong) {
message = "Au cours de la nuit, ";
} else {
message = "Après une dizaine de minutes de repos, ";
}
message +=
characterName + " récupère " + buildinline(rolls.inlinerolls[0]) + "+" + bonus + " PV. Il lui reste " + pr.current + " points de récupération";
sendChar(charId, "/direct " + message);
finalize();
});
}, finalize); //fin de iterSelected
}
function recharger(msg) {
var cmd = msg.content.split(" ");
if (cmd.length < 2) {
error("La fonction !cof-recharger attend au moins un argument", msg);
return;
}
var attackLabel = cmd[1];
var evt = {
type: 'recharger',
attributes: []
};
var grenaille = false;
if (msg.content.includes(' --grenaille')) grenaille = true;
getSelected(msg, function(selected) {
if (selected === undefined) {
sendPlayer(msg, "!cof-recharger sans sélection de tokens");
log("!cof-recharger requiert des tokens sélectionnés");
return;
}
iterSelected(selected, function(perso) {
var att = getAttack(attackLabel, perso);
if (att === undefined) {
error("Arme " + attackLabel + " n'existe pas pour " + perso.tokName, perso);
return;
}
var weaponName = att.weaponName;
var attrs =
findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: "charge_" + attackLabel
});
if (attrs.length < 1) {
perso.tokName = perso.tokName || perso.token.get('name');
log("Personnage " + perso.tokName + " sans charge " + attackLabel);
attrs = createObj('attribute', {
characterid: perso.charId,
name: 'charge_' + attackLabel,
current: 0,
max: 1
});
} else attrs = attrs[0];
var maxCharge = parseInt(attrs.get('max'));
if (isNaN(maxCharge)) {
error("max charge mal formée", attrs);
return;
}
var currentCharge = parseInt(attrs.get('current'));
if (isNaN(currentCharge)) {
error("charge mal formée", attrs);
return;
}
var attrGrenaille =
findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: "chargeGrenaille_" + attackLabel
});
var currentChargeGrenaille;
if (currentCharge < maxCharge) {
if (grenaille) {
if (attrGrenaille.length < 1) {
attrGrenaille = createObj('attribute', {
characterid: perso.charId,
name: 'chargeGrenaille_' + attackLabel,
current: 0
});
} else attrGrenaille = attrGrenaille[0];
currentChargeGrenaille = parseInt(attrGrenaille.get('current'));
if (isNaN(currentChargeGrenaille)) {
error("charge de grenaille mal formée", attrGrenaille);
return;
}
if (currentChargeGrenaille > currentCharge) currentChargeGrenaille = currentCharge;
evt.attributes.push({
attribute: attrGrenaille,
current: currentChargeGrenaille
});
attrGrenaille.set('current', currentChargeGrenaille + 1);
}
evt.attributes.push({
attribute: attrs,
current: currentCharge
});
attrs.set('current', currentCharge + 1);
updateNextInit(perso.token);
if (grenaille)
sendChar(perso.charId, "charge " + weaponName + " de grenaille.");
else
sendChar(perso.charId, "recharge " + weaponName);
return;
} else {
if (grenaille) { //On peut vouloir changer des charges normales en grenaille
if (attrGrenaille.length < 1) {
attrGrenaille = createObj('attribute', {
characterid: perso.charId,
name: 'chargeGrenaille_' + attackLabel,
current: 0
});
} else attrGrenaille = attrGrenaille[0];
currentChargeGrenaille = parseInt(attrGrenaille.get('current'));
if (isNaN(currentChargeGrenaille)) {
error("charge de grenaille mal formée", attrGrenaille);
return;
}
if (currentChargeGrenaille < currentCharge) {
evt.attributes.push({
attribute: attrGrenaille,
current: currentChargeGrenaille
});
attrGrenaille.set('current', currentChargeGrenaille + 1);
sendChar(perso.charId, "remplace une charge de " + weaponName + " par de la grenaille.");
return;
}
} else if (attrGrenaille.length > 0) {
attrGrenaille = attrGrenaille[0];
currentChargeGrenaille = parseInt(attrGrenaille.get('current'));
if (isNaN(currentChargeGrenaille)) {
error("charge de grenaille mal formée", attrGrenaille);
return;
}
if (currentChargeGrenaille > 0) {
evt.attributes.push({
attribute: attrGrenaille,
current: currentChargeGrenaille
});
attrGrenaille.set('current', currentChargeGrenaille - 1);
sendChar(perso.charId, "remplace une charge de grenaille de " + weaponName + " par une charge normale.");
return;
}
}
}
if (maxCharge == 1) {
sendChar(perso.charId, weaponName + " est déjà chargé");
} else {
sendChar(perso.charId, "a déjà tous ses " + weaponName + " chargés");
}
});
});
addEvent(evt);
}
//msg peut être un message ou un playerId
function peutController(msg, perso) {
if (msg === undefined) return true;
var playerId = getPlayerIdFromMsg(msg);
if (playerIsGM(playerId)) return true;
if (msg.selected && msg.selected.length > 0) {
if (perso.token.id == msg.selected[0]._id) return true;
var selectedPerso = tokenOfId(msg.selected[0]._id);
if (selectedPerso !== undefined && selectedPerso.charId == perso.charId) return true;
}
var character = getObj('character', perso.charId);
if (character === undefined) return false;
var cb = character.get('controlledby');
var res = cb.split(',').find(function(pid) {
if (pid == 'all') return true;
return (pid == playerId);
});
return (res !== undefined);
}
function boutonChance(msg) {
var args = msg.content.split(' ');
if (args.length < 2) {
error("La fonction !cof-bouton-chance n'a pas assez d'arguments", args);
return;
}
var evt = findEvent(args[1]);
if (evt === undefined) {
error("L'action est trop ancienne ou éte annulée", args);
return;
}
var perso = evt.personnage;
if (perso === undefined) {
error("Erreur interne du bouton de chance : l'évenement n'a pas de personnage", evt);
return;
}
if (!peutController(msg, perso)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var chance = ficheAttributeAsInt(perso, 'PC', 0);
if (chance <= 0) {
sendChar(perso.charId, " n'a plus de point de chance à dépenser...");
return;
}
var evtChance = {
type: 'chance'
};
chance--;
var action = evt.action;
if (action) { //alors on peut faire le undo
undoEvent(evt);
setFicheAttr(perso, 'PC', chance, evtChance,
" a dépensé un point de chance. Il lui en reste " + chance);
addEvent(evtChance);
switch (evt.type) {
case 'Attaque':
chanceCombat(perso, action);
return;
case 'jetPerso':
var options = action.options || {};
options.chance = (options.chance === undefined) ? 1 : options.chance + 1;
jetPerso(perso, action.caracteristique, action.difficulte, action.titre, action.playerId, options);
return;
case 'echapperEnveloppement':
var optionsEE = action.options || {};
optionsEE.chance = (optionsEE.chance === undefined) ? 1 : optionsEE.chance + 1;
echapperEnveloppement({
selected: action.selected,
content: '!cof-chance-echapper-enveloppement',
playerId: action.playerId,
options: optionsEE
});
return;
default:
error("Evenement avec une action, mais inconnue au niveau chance. Impossible d'annuler !", evt);
return;
}
}
error("Type d'évènement pas encore géré pour la chance", evt);
addEvent(evtChance);
}
function chance(msg) {
if (msg.selected === undefined) {
sendPlayer(msg, "!cof-chance sans sélection de token");
log("!cof-chance requiert de sélectionner un token");
return;
} else if (msg.selected.length != 1) {
sendPlayer(msg, "!cof-chance ne doit selectionner qu'un token");
log("!cof-chance requiert de sélectionner exactement un token");
return;
}
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("La fonction !cof-chance attend au moins un argument (combat ou autre)", msg);
return;
}
var tokenId = msg.selected[0]._id;
var perso = tokenOfId(tokenId);
if (perso === undefined) {
error(" !cof-chance ne fonctionne qu'avec des tokens qui représentent des personnages", perso);
return;
}
var name = perso.token.get('name');
var action;
if (cmd[1] == 'combat') { //further checks
var lastAct = lastEvent();
if (lastAct !== undefined) {
if (lastAct.type != 'Attaque' || lastAct.succes !== false) {
action = lastAct.action;
}
}
if (action === undefined ||
lastAct.action.attaquant.token.id != tokenId) {
error("Pas de dernière action de combat ratée trouvée pour " + name, lastAct);
return;
}
}
var chance = ficheAttributeAsInt(perso, 'PC', 3);
if (chance <= 0) {
sendChat("", name + " n'a plus de point de chance à dépenser...");
return;
}
var evt = {
type: 'chance'
};
chance--;
switch (cmd[1]) {
case 'autre':
setFicheAttr(perso, 'PC', chance, evt,
" a dépensé un point de chance. Il lui en reste " + chance);
addEvent(evt);
return;
case 'combat':
undoEvent();
setFicheAttr(perso, 'PC', chance, evt,
" a dépensé un point de chance. Il lui en reste " + chance);
addEvent(evt);
chanceCombat(perso, action);
return;
default:
error("argument de chance inconnu", cmd);
addEvent(evt);
return;
}
}
function chanceCombat(perso, action) {
// assumes that the original action was undone, re-attack with bonus
var options = action.options;
options.chance = (options.chance + 10) || 10;
options.rollsAttack = action.rollsAttack;
options.redo = true;
if (action.cibles) {
action.cibles.forEach(function(target) {
delete target.partialSaveAuto;
});
}
attack(action.player_id, perso, action.cibles, action.attack_label, options);
}
function persoUtiliseRuneEnergie(perso, evt) {
var attr = tokenAttribute(perso, 'runeDEnergie');
if (attr.length === 0) {
sendChar(perso.charId, "n'a pas de rune d'énergie");
return false;
}
attr = attr[0];
var dispo = attr.get('current');
if (dispo) {
sendChar(perso.charId, "utilise sa rune d'énergie pour relancer un d20 sur un test d'attaque, de FOR, DEX ou CON");
evt.attributes.push({
attribute: attr,
current: dispo
});
attr.set('current', 0);
return true;
}
sendChar(perso.charId, "a déjà utilisé sa rune d'énergie durant ce combat");
return false;
}
function runeEnergie(msg) {
if (!stateCOF.combat) {
sendPlayer(msg, "On ne peut utiliser les runes d'énergie qu'en combat");
return;
}
var cmd = msg.content.split(' ');
var evtARefaire;
var evt = {
type: "Rune d'énergie",
attributes: []
};
if (cmd.length > 1) { //On relance pour un événement particulier
evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
var perso = evtARefaire.personnage;
if (perso === undefined) {
error("Erreur interne du bouton de rune d'énergie : l'évenement n'a pas de personnage", evtARefaire);
return;
}
if (!peutController(msg, perso)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var action = evtARefaire.action;
if (action === undefined) {
error("Impossible de relancer l'action", evtARefaire);
return;
}
var carac = action.caracteristque;
if (carac == 'SAG' || carac == 'INT' || carac == 'CHA') {
sendChar(perso, "ne peut pas utiliser la rune d'énergie pour un test de " + carac);
return;
}
var options = action.options || {};
options.redo = true;
if (!persoUtiliseRuneEnergie(perso, evt)) return;
addEvent(evt);
switch (evtARefaire.type) {
case 'Attaque':
undoEvent(evtARefaire);
if (action.cibles) {
action.cibles.forEach(function(target) {
delete target.partialSaveAuto;
});
}
attack(action.player_id, perso, action.cibles, action.attack_label, options);
return;
case 'jetPerso':
undoEvent(evtARefaire);
delete options.roll; //On va le relancer
jetPerso(perso, action.caracteristique, action.difficulte, action.titre, action.playerId, options);
return;
case 'echapperEnveloppement':
undoEvent(evtARefaire);
delete options.roll;
echapperEnveloppement({
selected: action.selected,
content: '!cof-chance-echapper-enveloppement',
playerId: action.playerId,
options: options
});
return;
default:
return;
}
} else { //Juste pour vérifier l'attribut et le diminuer
getSelected(msg, function(selection) {
if (selection.length === 0) {
sendPlayer(msg, 'Pas de token sélectionné pour !cof-rune-energie');
return;
}
iterSelected(selection, function(perso) {
persoUtiliseRuneEnergie(perso, evt);
}); //fin iterSelected
addEvent(evt);
}); //fin getSelected
}
}
function persoUtiliseRunePuissance(perso, labelArme, evt) {
var attr = tokenAttribute(perso, 'runeDePuissance(' + labelArme + ')');
var arme = getAttack(labelArme, perso);
if (arme === undefined) {
error(perso.tokNname + " n'a pas d'arme associée au label " + labelArme, perso);
return false;
}
if (attr.length === 0) {
sendChar(perso.charId, "n'a pas de rune de puissance sur " + arme.weaponName);
return false;
}
attr = attr[0];
var dispo = attr.get('current');
if (dispo) {
sendChar(perso.charId, "utilise sa rune de puissance pour obtenir les DM maximum de son arme (" + arme.weaponName + ")");
evt.attributes.push({
attribute: attr,
current: dispo
});
attr.set('current', 0);
return true;
}
sendChar(perso.charId, "a déjà utilisé sa rune de puissance durant ce combat");
return false;
}
//!cof-rune-puissance label [evt.id]
function runePuissance(msg) {
if (!stateCOF.combat) {
sendPlayer(msg, "On ne peut utiliser les runes de puissance qu'en combat");
return;
}
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("Il faut spécifier le label de l'arme sur laquelle la rune de puissance est inscrite", cmd);
return;
}
var labelArme = cmd[1];
var evtARefaire;
var evt = {
type: "Rune de puissance",
attributes: []
};
if (cmd.length > 2) { //On relance pour un événement particulier
evtARefaire = findEvent(cmd[2]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
var perso = evtARefaire.personnage;
if (perso === undefined) {
error("Erreur interne du bouton de rune de puissance : l'évenement n'a pas de personnage", evtARefaire);
return;
}
if (!peutController(msg, perso)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var action = evtARefaire.action;
if (action === undefined) {
error("Impossible de relancer l'action", evtARefaire);
return;
}
var options = action.options || {};
options.redo = true;
options.maxDmg = true;
options.rollsAttack = action.rollsAttack;
action.cibles.forEach(function(target) {
delete target.rollsDmg;
});
if (!persoUtiliseRunePuissance(perso, labelArme, evt)) return;
addEvent(evt);
switch (evtARefaire.type) {
case 'Attaque':
undoEvent(evtARefaire);
attack(action.player_id, perso, action.cibles, action.attack_label, options);
return;
default:
return;
}
} else { //Juste pour vérifier l'attribut et le diminuer
getSelected(msg, function(selection) {
if (selection.length === 0) {
sendPlayer(msg, 'Pas de token sélectionné pour !cof-rune-puissance');
return;
}
iterSelected(selection, function(perso) {
persoUtiliseRunePuissance(perso, labelArme, evt);
}); //fin iterSelected
addEvent(evt);
}); //fin getSelected
}
}
//!cof-pousser-kaia evt.id
function kiai(msg) {
if (!stateCOF.combat) {
sendPlayer(msg, "On ne peut pousser un kiai qu'en combat");
return;
}
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("Il manque l'id de l'attaque sur laquelle pousser le kiai", cmd);
return;
}
var evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
var perso = evtARefaire.personnage;
if (perso === undefined) {
error("Erreur interne du bouton de kiai : l'évenement n'a pas de personnage", evtARefaire);
return;
}
if (!peutController(msg, perso)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var action = evtARefaire.action;
if (action === undefined) {
error("Impossible de relancer l'action", evtARefaire);
return;
}
var attrKiai = tokenAttribute(perso, 'kiai');
if (attrKiai.length === 0) {
error("Le personnage " + perso.token.get('name') + " ne sait pas pousser de kiai", cmd);
return;
}
attrKiai = attrKiai[0];
var currentKiai = parseInt(attrKiai.get('current'));
if (isNaN(currentKiai) || currentKiai < 1) {
sendPlayer(msg, perso.token.get('name') + " ne peut plus pousser de kiai pendant ce combat.");
return;
}
var evt = {
type: "Kiai",
attributes: [{
attribute: attrKiai,
current: currentKiai
}]
};
attrKiai.set('current', currentKiai - 1);
if (currentKiai > 1) {
setTokenAttr(perso, 'rechargeDuKiai', randomInteger(6), evt, undefined, getInit());
}
var options = action.options || {};
options.redo = true;
options.maxDmg = true;
options.rollsAttack = action.rollsAttack;
action.cibles.forEach(function(target) {
delete target.rollsDmg;
});
addEvent(evt);
switch (evtARefaire.type) {
case 'Attaque':
undoEvent(evtARefaire);
attack(action.player_id, perso, action.cibles, action.attack_label, options);
return;
default:
return;
}
}
//Devrait être appelé seulement depuis un bouton
//!cof-esquive-fatale evtid target_id
function esquiveFatale(msg) {
var cmd = msg.content.split(' ');
var evtARefaire;
var evt = {
type: "Esquive fatale",
attributes: []
};
if (cmd.length < 3) {
error("Il manque des arguments à !cof-esquive-fatale", cmd);
return;
}
evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'attaque est trop ancienne ou a été annulée", cmd);
return;
}
var action = evtARefaire.action;
if (action === undefined) {
error("Impossible d'esquiver l'attaque", evtARefaire);
return;
}
var perso = action.cibles[0];
if (perso === undefined) {
error("Erreur interne du bouton de 'esquive fatale : l'évenement n'a pas de personnage", evtARefaire);
return;
}
var adversaire = tokenOfId(cmd[2]);
if (adversaire === undefined) {
sendPlayer(msg, "Il faut cibler un token valide");
return;
}
var attaquant = action.attaquant;
if (attaquant.token.id == adversaire.token.id) {
sendPlayer(msg, "Il faut cibler un autre adversaire que l'attaquant");
return;
}
if (distanceCombat(perso.token, adversaire.token) > 0) {
sendChar(perso.charId, "doit choisir un adversaire au contact pour l'esquive fatale");
return;
}
var ennemisAuContact = perso.ennemisAuContact;
if (ennemisAuContact === undefined) {
error("Ennemis au contact non définis", perso);
} else {
var i = ennemisAuContact.find(function(tok) {
return (tok.id == adversaire.token.id);
});
if (i === undefined) {
sendPlayer(msg, "Il faut cibler un adversaire au contact pour l'esquive fatale");
return;
}
}
if (!peutController(msg, perso)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var options = action.options || {};
var attr = tokenAttribute(perso, 'esquiveFatale');
if (attr.length === 0) {
sendChar(perso.charId, "ne sait pas faire d'esquive fatale");
return;
}
attr = attr[0];
var dispo = parseInt(attr.get('current'));
if (isNaN(dispo) || dispo < 1) {
sendChar(perso.charId, "a déjà fait une esquive fatale durant ce combat");
return;
}
adversaire.tokName = adversaire.token.get('name');
sendChar(perso.charId, "s'arrange pour que l'attaque touche " + adversaire.tokName);
evt.attributes.push({
attribute: attr,
current: dispo
});
attr.set('current', 0);
addEvent(evt);
undoEvent(evtARefaire);
adversaire.esquiveFatale = true;
options.redo = true;
attack(action.player_id, attaquant, [adversaire], action.attack_label, options);
}
function intercepter(msg) {
getSelected(msg, function(selected) {
iterSelected(selected, function(cible) {
var charId = cible.charId;
var character = getObj('character', charId);
if (character === undefined) {
error("L'argument de !cof-intercepter n'est pas une id de token valide (personnage non défini)", msg.content);
return;
}
cible.tokName = cible.token.get('name');
cible.name = character.get('name');
if (attributeAsBool(cible, 'intercepter')) {
sendChar(charId, " a déjà intercepté une attaque ce tour");
return;
}
var voieMeneur = charAttributeAsInt(cible, "voieDuMeneurDHomme", 0);
if (voieMeneur < 2) {
error(cible.tokName + " n'a pas un rang suffisant dans la voie du meneur d'homme pour intercepter l'attaque", voieMeneur);
return;
}
var attaque;
var lastAct = lastEvent();
if (lastAct !== undefined) {
attaque = lastAct.action;
}
if (attaque === undefined) {
sendChar(charId, "la dernière action trouvée n'est pas une attaque, impossible d'intercepter");
return;
}
if (attaque.cibles.length === 0) {
sendChar(charId, "la dernière attaque n'a touché aucune cible, impossible d'intercepter");
return;
}
if (attaque.cibles.length > 1) {
sendChar(charId, "la dernière attaque a touché plus d'une cible, impossible d'intercepter");
return;
}
var targetName = attaque.cibles[0].tokName;
if (targetName === undefined) {
error("Le token de la dernière attaque est indéfini", attaque);
return;
}
if (distanceCombat(cible.token, attaque.cibles[0].token) > 0) {
sendChar(charId, " est trop loin de " + targetName + " pour intercepter l'attaque");
return;
}
var evt = {
type: 'interception'
};
setTokenAttr(cible, 'intercepter', true, evt,
"se met devant " + targetName + " pour intercepter l'attaque !");
// On annule l'ancienne action
undoEvent();
// Puis on refait en changeant la cible
var options = attaque.options;
options.intercepter = voieMeneur;
options.rollsAttack = attaque.rollsAttack;
options.evt = evt;
options.redo = true;
cible.rollsDmg = attaque.cibles[0].rollsDmg;
attack(attaque.player_id, attaque.attaquant, [cible], attaque.attack_label, options);
});
});
}
//simplement prendre les DM à la place d'un autre
function interposer(msg) {
getSelected(msg, function(selected) {
iterSelected(selected, function(cible) {
var charId = cible.charId;
var character = getObj('character', charId);
if (character === undefined) {
error("L'argument de !cof-interposer n'est pas une id de token valide (personnage non défini)", msg.content);
return;
}
cible.tokName = cible.token.get('name');
cible.name = character.get('name');
if (attributeAsBool(cible, 'interposer')) {
sendChar(charId, " a déjà intercepté une attaque ce tour");
return;
}
var attaque;
var lastAct = lastEvent();
if (lastAct !== undefined) {
attaque = lastAct.action;
}
if (attaque === undefined) {
sendChar(charId, "la dernière action trouvée n'est pas une attaque, impossible d'intercepter");
return;
}
if (attaque.cibles.length === 0) {
sendChar(charId, "la dernière attaque n'a touché aucune cible, impossible de s'interposer");
return;
}
if (attaque.cibles.length > 1) {
sendChar(charId, "la dernière attaque a touché plus d'une cible, impossible de s'interposer en utilisant le script");
return;
}
var target = attaque.cibles[0];
var targetName = target.tokName;
if (targetName === undefined) {
error("Le token de la dernière attaque est indéfini", attaque);
return;
}
if (distanceCombat(cible.token, target.token) > 0) {
sendChar(charId, " est trop loin de " + targetName + " pour s'interposer");
return;
}
var evt = {
type: 'interposer'
};
setTokenAttr(cible, 'interposer', true, evt,
"se met devant " + targetName + " pour intercepter l'attaque !");
var pvApres = target.token.get('bar1_value');
// On annule l'ancienne action
undoEvent();
// On calcule ensuite les pv perdus, et on les applique au défenseur
var pvPerdus = target.token.get('bar1_value') - pvApres;
// Puis on refait en changeant la cible
var options = attaque.options;
options.interposer = pvPerdus;
options.rollsAttack = attaque.rollsAttack;
options.rollsDmg = attaque.rollsDmg;
options.evt = evt;
options.redo = true;
cible.rollsDmg = target.rollsDmg;
attack(attaque.player_id, attaque.attaquant, [cible], attaque.attack_label, options);
});
});
}
function exemplaire(msg) {
getSelected(msg, function(selected) {
iterSelected(selected, function(cible) {
var charId = cible.charId;
if (attributeAsBool(cible, 'exemplaire')) {
sendChar(charId, " a déjà montré l'exemple à ce tour");
return;
}
var attaque;
var lastAct = lastEvent();
if (lastAct !== undefined) {
if (lastAct.type == 'Attaque' && lastAct.succes === false) {
attaque = lastAct.action;
}
}
if (attaque === undefined) {
sendChar(charId, "la dernière action trouvée n'est pas une attaque ratée, impossible de montrer l'exemple");
return;
}
var attackerName = attaque.attaquant.token.get('name');
if (attackerName === undefined) {
error("Le token de la dernière attaque est indéfini", attaque);
return;
}
var evt = {
type: "Montrer l'exemple"
};
setTokenAttr(cible, 'exemplaire', true, evt,
"montre l'exemple à " + attackerName);
// On annule l'ancienne action
undoEvent();
// Puis on refait
var options = attaque.options;
options.evt = evt;
options.redo = true;
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
});
});
}
function parseOptions(msg) {
var pageId, playerId;
if (msg.selected && msg.selected.length > 0) {
var firstSelected = getObj('graphic', msg.selected[0]._id);
if (firstSelected === undefined) {
error("Un token sélectionné n'est pas trouvé en interne", msg.selected);
return;
}
pageId = firstSelected.get('pageid');
} else {
playerId = getPlayerIdFromMsg(msg);
pageId = getPageId(playerId);
}
var opts = msg.content.split(' --');
var cmd = opts.shift().split(' ');
cmd = cmd.filter(function(c) {
return c !== '';
});
var options = {
pageId: pageId,
playerId: playerId,
cmd: cmd
};
opts.forEach(function(arg) {
cmd = arg.trim().split(' ');
switch (cmd[0]) {
case "attaqueMentale":
options[cmd[0]] = true;
break;
case "lanceur":
if (cmd.length < 2) {
error("Il faut préciser l'id ou le nom du lanceur", arg);
return;
}
options.lanceur = tokenOfId(cmd[1], cmd[1], pageId);
if (options.lanceur === undefined) {
error("Argument de --lanceur non valide", cmd);
}
return;
case 'puissant':
if (cmd.length < 2) {
options.puissant = "on";
return;
}
switch (cmd[1]) {
case "oui":
options.puissant = "on";
return;
case "non":
options.puissant = "off";
return;
case "duree":
options.puissantDuree = true;
return;
default:
error("Option puissant non reconnue", cmd);
}
return;
case "mana":
if (cmd.length < 2) {
error("Pas assez d'argument pour --mana", cmd);
return;
}
var cout;
if (cmd.length > 2 && cmd[1] !== '' && cmd[2] !== '') {
options.lanceur = tokenOfId(cmd[1], cmd[1], pageId);
if (options.lanceur === undefined) {
error("Premier argument de --mana non valide", cmd);
return;
}
cout = parseInt(cmd[2]);
} else {
cout = parseInt(cmd[1]);
}
if (isNaN(cout) || cout < 0) {
error("Cout en mana incorrect", cmd);
return;
}
options.mana = cout;
return;
case "tempeteDeMana":
parseTempeteDeMana(cmd, options);
return;
case "rang":
if (cmd.length < 2) {
error("Usage : --rang r", cmd);
return;
}
var rang = parseInt(cmd[1]);
if (isNaN(rang) || rang < 1) {
error("Le rang doit être un nombre positif");
return;
}
options.rang = rang;
break;
case 'limiteParJour':
if (cmd.length < 2) {
error("Il manque la limite journalière", cmd);
return;
}
var limiteParJour = parseInt(cmd[1]);
if (isNaN(limiteParJour) || limiteParJour < 1) {
error("La limite journalière doit être un nombre positif", cmd);
return;
}
options.limiteParJour = limiteParJour;
if (cmd.length > 2) {
cmd.splice(0, 2);
options.limiteParJourRessource = cmd.join('_');
}
return;
case 'limiteCibleParJour':
if (cmd.length < 2) {
error("Il manque la limite journalière", cmd);
return;
}
var limiteCibleParJour = parseInt(cmd[1]);
if (isNaN(limiteCibleParJour) || limiteCibleParJour < 1) {
error("La limite journalière doit être un nombre positif", cmd);
return;
}
options.limiteCibleParJour = limiteCibleParJour;
if (cmd.length > 2) {
cmd.splice(0, 2);
options.limiteCibleParJourRessource = cmd.join('_');
}
return;
case 'limiteParCombat':
if (cmd.length < 2) {
options.limiteParCombat = 1;
return;
}
var limiteParCombat = parseInt(cmd[1]);
if (isNaN(limiteParCombat) || limiteParCombat < 1) {
error("La limite par combat doit être un nombre positif", cmd);
return;
}
options.limiteParCombat = limiteParCombat;
if (cmd.length > 2) {
cmd.splice(0, 2);
options.limiteParCombatRessource = cmd.join('_');
}
return;
case "portee":
if (cmd.length < 2) {
error("Pas assez d'argument pour --portee n", cmd);
return;
}
var portee;
if (cmd.length > 2) {
var tokPortee = tokenOfId(cmd[1], cmd[1], pageId);
if (tokPortee === undefined) {
error("Premier argument de --portee non valide", cmd);
return;
}
portee = parseInt(cmd[2]);
} else {
portee = parseInt(cmd[1]);
}
if (isNaN(portee) || portee < 0) {
error("Portée incorrecte", cmd);
return;
}
options.portee = portee;
return;
case 'saveParTour':
options.saveParTour = parseSave(cmd);
return;
case 'save':
options.save = parseSave(cmd);
return;
case 'dose':
if (cmd.length < 2) {
error("Il faut le nom de la dose", cmd);
return;
}
options.dose = cmd[1];
return;
case 'decrAttribute':
if (cmd.length < 2) {
error("Erreur interne d'une commande générée par bouton", opts);
return;
}
var attr = getObj('attribute', cmd[1]);
if (attr === undefined) {
log("Attribut à changer perdu");
log(cmd);
return;
}
options.decrAttribute = attr;
return;
case 'valeur':
if (cmd.length < 2) {
error("Il manque la valeur en argument de l'option --valeur", opts);
return;
}
options.valeur = cmd[1];
if (cmd.length > 2) options.valeurMax = cmd[2];
return;
case "fx":
getFx(cmd, 'fx', options);
return;
case 'message':
if (arg.length > 8) options.message = arg.substring(8);
return;
case "targetFx":
getFx(cmd, 'targetFx', options);
break;
case "classeEffet":
if (cmd.length < 2) {
sendChat("COF", "Il manque un argument à l'option --classeEffet");
return;
}
options.classeEffet = cmd[1];
return;
case "nonVivant":
options.nonVivant = true;
if (cmd.length > 1) {
var nonVivantPerso = tokenOfId(cmd[1], cmd[1], pageId);
if (nonVivantPerso) {
options.nonVivant = charAttributeAsBool(nonVivantPerso, 'nonVivant');
}
}
return;
case 'message':
if (cmd.length < 2) {
error("Il manque le message après --message", cmd);
return;
}
options.messages = options.messages || [];
options.messages.push(cmd.slice(1).join(' '));
return;
default:
return;
}
});
return options;
}
function surprise(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined) {
error("Problème de parse options", msg.content);
return;
}
var testSurprise;
if (cmd.length > 1) {
testSurprise = parseInt(cmd[1]);
if (isNaN(testSurprise)) testSurprise = undefined;
}
var bonusAttrs = ['vigilance', 'perception'];
if (!options.nonVivant) bonusAttrs.push('radarMental');
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "!cof-surprise sans sélection de token");
log("!cof-surprise requiert de sélectionner des tokens");
return;
}
var display;
if (testSurprise === undefined) {
display = startFramedDisplay(playerId, "<b>Surprise !</b>");
} else {
display = startFramedDisplay(playerId, "Test de surprise difficulté " + testSurprise);
}
var evt = {
type: 'surprise',
};
var tokensToProcess = selected.length;
var sendEvent = function() {
if (tokensToProcess == 1) {
addEvent(evt);
sendChat("", endFramedDisplay(display));
}
tokensToProcess--;
};
iterSelected(selected, function(perso) {
if (!isActive(perso)) {
sendEvent();
return;
}
var name = perso.token.get('name');
if (charAttributeAsBool(perso, 'immuniteContreSurprise')) {
addLineToFramedDisplay(display, name + " n'est pas surpris" + eForFemale(perso.charId));
sendEvent();
}
var bonusSurprise = 0;
if (surveillance(perso)) {
bonusSurprise += 5;
setTokenAttr(perso, 'bonusInitEmbuscade', 5, evt, "garde un temps d'avance grâce à son compagnon animal");
initPerso(perso, evt, true);
}
if (attributeAsBool(perso, 'sixiemeSens')) bonusSurprise += 5;
if (testSurprise !== undefined) {
testCaracteristique(perso, 'SAG', testSurprise, {
bonus: bonusSurprise,
bonusAttrs: bonusAttrs
}, evt,
function(tr) {
var result;
if (tr.reussite) result = "réussi";
else {
result = "raté, " + name + " est surpris";
result += eForFemale(perso.charId);
setState(perso, 'surpris', true, evt);
}
var message = name + " fait " + tr.texte + " : " + result;
addLineToFramedDisplay(display, message);
sendEvent();
});
} else { //no test
setState(perso, 'surpris', true, evt);
addLineToFramedDisplay(display, name + " est surpris." + eForFemale(perso.charId));
sendEvent();
}
}, sendEvent);
});
}
function interchangeable(attackingToken, target, pageId) { //détermine si il y a assez de tokens
var token = target.token;
var charId = target.charId;
var res = {
result: false,
targets: []
};
if (!isActive(target)) return res;
var meuteAttr =
findObjs({
_type: 'attribute',
_characterid: charId,
name: 'interchangeable'
});
if (meuteAttr.length < 1) return res;
meuteAttr = parseInt(meuteAttr[0].get('current'));
if (isNaN(meuteAttr) || meuteAttr <= 0) return res;
var tokens = findObjs({
_type: 'graphic',
_subtype: 'token',
represents: charId,
_pageid: pageId
});
tokens = tokens.filter(function(tok) {
return isActive({
token: tok
});
});
res.result = (tokens.length > meuteAttr);
// Now select the tokens which could be valid targets
var p = distanceCombat(attackingToken, token);
if (p === 0) { //cible au contact, on garde toutes celles au contact
res.targets = tokens.filter(function(tok) {
var d = distanceCombat(attackingToken, tok);
return (d === 0);
});
} else { // cible à distance, on garde celles au contact de la cible
res.targets = tokens.filter(function(tok) {
var d = distanceCombat(token, tok);
return (d === 0);
});
}
return res;
}
var alliesParPerso = {};
var listeCompetences = {
FOR: [],
DEX: [],
CON: [],
SAG: [],
INT: [],
CHA: []
};
// Appelé uniquement après le "ready" et lorsqu'on modifie un handout (fonctionne après l'ajout et la destruction d'un handout)
// Du coup, alliesParPerso est toujours à jour
function changeHandout(hand, prev) {
if (prev && prev.name && prev.name.startsWith("Equipe ")) {
var handouts = findObjs({
_type: 'handout'
});
alliesParPerso = {};
handouts.forEach(parseHandout);
} else if (hand) {
parseHandout(hand);
}
}
function charactersInHandout(note, nomEquipe) {
note = note.trim();
if (note.startsWith('<p>')) note = note.substring(3);
note = note.trim().replace(/<p>/g, '<br>');
note = note.replace(/<\/p>/g, '');
var names = note.trim().split('<br>');
var persos = new Set();
names.forEach(function(name) {
name = name.replace(/<(?:.|\s)*?>/g, ''); //Pour enlever les <h2>, etc
name = name.trim();
if (name.length === 0) return;
var characters = findObjs({
_type: 'character',
});
characters = characters.filter(function(c) {
return c.get('name').trim() == name;
});
if (characters.length === 0) {
log(name + " dans l'équipe " + nomEquipe + " est inconnu");
return;
}
if (characters.length > 1) {
var nonArch = characters.filter(function(c) {
return !(c.get('archived'));
});
if (nonArch.length > 0) characters = nonArch;
if (characters.length > 1) {
log(name + " dans l'équipe " + nomEquipe + " est en double");
}
}
characters.forEach(function(character) {
persos.add(character.id);
});
});
return persos;
}
function parseHandout(hand) {
var handName = hand.get('name');
if (handName.startsWith("Equipe ")) {
hand.get('notes', function(note) { // asynchronous
var persos = charactersInHandout(note, handName);
persos.forEach(function(charId) {
var ancien = alliesParPerso[charId];
if (ancien === undefined) {
ancien = new Set();
alliesParPerso[charId] = ancien;
}
persos.forEach(function(aci) {
if (aci == charId) return;
ancien.add(aci);
});
});
}); //end hand.get('notes')
} else if (handName == 'Compétences' || handName == 'Competences') {
listeCompetences = {
FOR: [],
DEX: [],
CON: [],
SAG: [],
INT: [],
CHA: []
};
hand.get('notes', function(note) { // asynchronous
var carac; //La carac dont on spécifie les compétences actuellement
var lignes = note.trim().replace(/<p>|<\/p>/g, '<br>').split('<br>');
lignes.forEach(function(ligne) {
ligne = ligne.trim();
var header = ligne.split(':');
if (header.length > 1) {
var c = header.shift().trim().toUpperCase();
if (!isCarac(c)) return;
carac = c;
ligne = header.join(':').trim();
}
if (ligne.length === 0) return;
if (carac === undefined) {
error("Compétences sans caractéristique associée", note);
return;
}
var comps = ligne.split(/, |\/| /);
comps.forEach(function(comp) {
if (comp.length === 0) return;
listeCompetences[carac].push(comp);
});
});
}); //end hand.get(notes)
}
}
function estControlleParJoueur(charId) {
var character = getObj('character', charId);
if (character === undefined) return false;
return character.get('controlledby').length > 0;
}
function estPJ(perso) {
var typePerso = ficheAttribute(perso, 'type_personnage', 'PJ');
if (typePerso == 'PNJ') return false;
var dv = ficheAttributeAsInt(perso, 'DV', 0);
if (dv === 0) return false;
if (perso.token.get('bar1_link') === '') return false;
return estControlleParJoueur(perso.charId);
}
function estAllieJoueur(perso) {
if (estControlleParJoueur(perso.charId)) return true;
var allies = alliesParPerso[perso.charId];
if (allies === undefined) return false;
var res = false;
allies.forEach(function(p) {
res = res || estControlleParJoueur(p);
});
return res;
}
function setTokenFlagAura(perso) {
var token = perso.token;
if (aura_token_on_turn) {
// ennemi => rouge
var aura2_color = '#CC0000';
if (estAllieJoueur(perso)) {
// equipe => vert
aura2_color = '#59E594';
}
token.set('aura2_radius', '0.1');
token.set('aura2_color', aura2_color);
token.set('showplayers_aura2', true);
} else token.set('status_flying-flag', true);
}
function removeTokenFlagAura(token) {
if (aura_token_on_turn) {
token.set('aura2_radius', '');
token.set('showplayers_aura2', false);
} else token.set('status_flying-flag', false);
}
//Si listActions est fourni, ça doit faire référence à une ability
//dont le nom commence et termine par #, contenant une liste d'actions
//à afficher
function turnAction(perso, playerId, listActions) {
var pageId = perso.token.get('pageid');
// Toutes les Abilities du personnage lié au Token
var abilities = findObjs({
_type: 'ability',
_characterid: perso.charId,
});
var title = 'Actions possibles :';
if (listActions) {
title = listActions;
var fullListActions = '#' + listActions + '#';
listActions = abilities.find(function(a) {
return a.get('name') == fullListActions;
});
}
var actionsDuTour = [];
var actionsParDefaut = false;
var formeDarbre = false;
if (listActions) {
actionsDuTour = [listActions];
} else {
if (!isActive(perso)) {
sendChar(perso.charId, "ne peut pas agir à ce tour");
return true;
}
//On recherche dans le Personnage s'il a une "Ability" dont le nom est #Actions#" ou "#TurnAction#".
formeDarbre = attributeAsBool(perso, 'formeDArbre');
if (formeDarbre) {
actionsDuTour = abilities.filter(function(a) {
return (a.get('name') == '#FormeArbre#');
});
if (actionsDuTour.length === 0) formeDarbre = false;
else actionsParDefaut = true;
}
if (actionsDuTour.length === 0) {
actionsDuTour = abilities.filter(function(a) {
switch (a.get('name')) {
case '#TurnAction#':
return true;
case '#Actions#':
actionsParDefaut = true;
return true;
default:
return false;
}
});
}
}
//Si elle existe, on lui chuchotte son exécution
var actionsAAfficher;
var ligne = '';
var command = '';
//Les dégâts aux personnages enveloppés par perso
var attrs_enveloppe = tokenAttribute(perso, 'enveloppe');
attrs_enveloppe.forEach(function(a) {
var cible = tokenOfIdName(a.get('current'), pageId);
if (cible === undefined) {
error("Attribut d'enveloppe mal formé ou obsolète", a.get('current'));
return;
}
var enveloppeDM = a.get('max');
if (enveloppeDM.startsWith('ability ')) {
enveloppeDM = enveloppeDM.substring(8);
var abEnveloppe = abilities.find(function(abilitie) {
return (abilitie.get('name') === enveloppeDM);
});
if (abEnveloppe) {
command = abEnveloppe.get('action').trim();
command = replaceAction(command, perso);
command = command.replace(new RegExp(escapeRegExp('@{target|token_id}'), 'g'), cible.token.id);
ligne += bouton(command, "Infliger DMS à " + cible.tokName, perso, false) + '<br />';
}
} else if (enveloppeDM.startsWith('label ')) {
actionsAAfficher = true;
command = '!cof-attack ' + perso.token.id + ' ' + cible.token.id + ' ' + enveloppeDM.substring(6) + ' --auto --acide --effet paralyseTemp [[2d6]] --save CON 15';
ligne += bouton(command, "Infliger DMs à " + cible.tokName, perso, false) + '<br />';
} //else pas reconnu
});
if (attributeAsBool(perso, 'enveloppePar')) {
actionsAAfficher = true;
command = '!cof-echapper-enveloppement --target ' + perso.token.id;
ligne += bouton(command, 'Sortir de la créature', perso, false) + '<br />';
} else {
if (attributeAsBool(perso, 'estAgrippePar')) {
actionsAAfficher = true;
command = '!cof-liberer-agrippe --target ' + perso.token.id;
ligne += bouton(command, 'Se libérer', perso, false) + '<br />';
}
if (formeDarbre) {
actionsAAfficher = true;
command = '!cof-attack @{selected|token_id} @{target|token_id} ["Branches",["@{selected|NIVEAU}",0],20,[1,6,3,0],0]';
ligne += bouton(command, 'Attaque', perso, false) + '<br />';
}
//On cherche si il y a une armée conjurée à attaquer
var attrs_armee =
findObjs({
_type: "attribute",
name: 'armeeConjuree',
});
if (attrs_armee.length > 0) {
var allTokens =
findObjs({
_type: "graphic",
_pageid: pageId,
_subtype: "token",
layer: "objects"
});
var scale = computeScale(pageId);
var px = perso.token.get('left');
var py = perso.token.get('top');
var pxp = px + 10 * PIX_PER_UNIT / scale;
var pxm = px - 10 * PIX_PER_UNIT / scale;
var pyp = py + 10 * PIX_PER_UNIT / scale;
var pym = py - 10 * PIX_PER_UNIT / scale;
var ps = tokenSize(perso.token, 0);
pxp += ps;
pxm -= ps;
pyp += ps;
pym -= ps;
attrs_armee.forEach(function(aa) {
var aacid = aa.get('characterid');
if (aacid == perso.charId) return;
var invocId = aa.get('current');
if (invocId == perso.charId) return;
var allies = alliesParPerso[invocId] || new Set();
if (allies.has(perso.charId)) return;
allTokens.forEach(function(t) {
if (t.get('represents') == aacid) {
//teste si dans un carré de 20 m de coté autour de l'armée.
var tx = t.get('left');
var ty = t.get('top');
if (tx < pxp && tx > pxm && ty < pyp && ty > pym) {
command = '!cof-attack ' + perso.token.id + ' ' + t.id + ' ["AttaqueArmée",[0,0],20,[0,6,' + (charAttributeAsInt(perso, 'NIVEAU', 1) + 1) + ',0],20] --auto --attaqueArmeeConjuree';
ligne += bouton(command, "Attaque de l'armée", perso, false) + '<br />';
}
}
});
});
}
//Les soins pour les élémentaires
if (charAttributeAsBool(perso, 'corpsElementaire')) {
command = '!cof-soin 5';
ligne += bouton(command, "Régénération", perso, false) + " si source élémentaire proche<br />";
}
//La liste d'action proprement dite
if (actionsDuTour.length > 0) {
// on récupère la valeur de l'action dont chaque Macro #/Ability % est mis dans un tableau 'action'
var actions = actionsDuTour[0].get('action')
.replace(/\n/gm, '').replace(/\r/gm, '')
.replace(/%#([^#]*)#/g, '\n!cof-liste-actions $1')
.replace(/\/\/%/g, '\n\/\/')
.replace(/\/\/#/g, '\n\/\/')
.replace(/%/g, '\n%').replace(/#/g, '\n#')
.split("\n");
if (actions.length > 0) {
// Toutes les Macros
var macros = findObjs({
_type: 'macro'
});
var found;
// On recherche si l'action existe (Ability % ou Macro #)
actions.forEach(function(action, i) {
action = action.trim();
if (action.length > 0) {
if (action.startsWith('//')) return; //commented out line
var actionCommands = action.split(' ');
var actionCmd = actionCommands[0];
var actionText = actionCmd.replace(/-/g, ' ').replace(/_/g, ' ');
found = false;
if (actionCmd.startsWith('%')) {
// Ability
actionCmd = actionCmd.substr(1);
actionText = actionText.substr(1);
abilities.forEach(function(abilitie, index) {
if (found) return;
if (abilitie.get('name') === actionCmd) {
// l'ability existe
found = true;
command = abilitie.get('action').trim();
if (actionCommands.length > 1) {
//On rajoute les options de l'ability
command += action.substr(action.indexOf(' '));
}
ligne += bouton(command, actionText, perso, false) + '<br />';
}
});
} else if (actionCmd.startsWith('#')) {
// Macro
actionCmd = actionCmd.substr(1);
actionText = actionText.substr(1);
macros.forEach(function(macro, index) {
if (found) return;
if (macro.get('name') === actionCmd) {
found = true;
command = macro.get('action').trim();
if (actionCommands.length > 1) {
//On rajoute les options de la macro
command += action.substr(action.indexOf(' '));
}
ligne += bouton(command, actionText, perso, false) + '<br />';
}
});
} else if (actionCmd.startsWith('!')) {
// commande API
if (actionCommands.length > 1) {
actionText = actionCommands[1].replace(/-/g, ' ').replace(/_/g, ' ');
}
command = action;
ligne += bouton(command, actionText, perso, false) + '<br />';
found = true;
}
if (found) {
actionsAAfficher = true;
} else {
// Si on n'a toujours rien trouvé, on ajoute un petit log
log('Ability et macro non trouvé : ' + action);
}
}
});
}
} else if (stateCOF.options.affichage.val.actions_par_defaut.val) {
actionsParDefaut = true;
abilities.forEach(function(a) {
var actionAbility = a.get('name').replace(/-/g, ' ').replace(/_/g, ' ');
command = a.get('action').trim();
ligne += bouton(command, actionAbility, perso, false) + '<br />';
});
}
if (actionsParDefaut) {
actionsAAfficher = true;
command = "!cof-attendre ?{Nouvelle initiative}";
ligne += bouton(command, 'Attendre', perso, false) + '<br />';
if (!charAttributeAsBool(perso, 'armeeConjuree')) {
command = "!cof-action-defensive ?{Action défensive|simple|totale}";
ligne += bouton(command, 'Se défendre', perso, false) + '<br />';
if (stateCOF.options.affichage.val.manoeuvres.val) {
command = "!cof-manoeuvre @{selected|token_id} @{target|token_id} ?{Manoeuvre?|aveugler|bloquer|desarmer|faireDiversion|menacer|renverser|tenirADistance|repousser}";
ligne += bouton(command, 'Manoeuvres', perso, false) + '<br />';
}
}
}
for (var etat in cof_states) {
var saveEtat = boutonSaveState(perso, etat);
if (saveEtat) {
ligne += saveEtat + '<br />';
actionsAAfficher = true;
}
}
}
if (actionsAAfficher) {
// on envoie la liste aux joueurs qui gèrent le personnage dont le token est lié
var last_playerid;
// on récupère les players_ids qui controllent le Token
var player_ids;
if (playerId) player_ids = [playerId];
else player_ids = getPlayerIds(perso);
if (player_ids.length > 0) {
_.each(player_ids, function(playerid) {
last_playerid = playerid;
var display = startFramedDisplay(playerid, title, perso, {
chuchote: true
});
addLineToFramedDisplay(display, ligne);
sendChat('', endFramedDisplay(display));
});
}
// En prime, on l'envoie au MJ, si besoin
if (stateCOF.options.affichage.val.MJ_voit_actions.val || player_ids.length === 0) {
var display = startFramedDisplay(last_playerid, title, perso, {
chuchote: 'gm'
});
addLineToFramedDisplay(display, ligne);
sendChat('', endFramedDisplay(display));
}
}
return (actionsDuTour.length > 0 || actionsAAfficher);
}
function apiTurnAction(msg) {
var cmd = msg.content.split(' ');
var abil;
if (cmd.length > 1 && !(cmd[1].startsWith('--'))) abil = cmd[1];
getSelected(msg, function(selected, playerId) {
iterSelected(selected, function(perso) {
var actions = turnAction(perso, playerId, abil);
if (!actions) {
abil = abil || '';
sendChar(perso.charId, "n'a pas de liste d'actions " + abil + " définie");
}
});
});
}
function setActiveToken(tokenId, evt) {
var pageId = Campaign().get('initiativepage');
if (stateCOF.activeTokenId) {
if (tokenId == stateCOF.activeTokenId) return;
evt.activeTokenId = stateCOF.activeTokenId;
var prevToken = getObj('graphic', stateCOF.activeTokenId);
if (prevToken) {
affectToken(prevToken, 'statusmarkers', prevToken.get('statusmarkers'), evt);
affectToken(prevToken, 'aura2_radius', prevToken.get('aura2_radius'), evt);
affectToken(prevToken, 'aura2_color', prevToken.get('aura2_color'), evt);
affectToken(prevToken, 'showplayers_aura2', prevToken.get('showplayers_aura2'), evt);
removeTokenFlagAura(prevToken);
} else {
if (pageId) {
prevToken = findObjs({
_type: 'graphic',
_subtype: 'token',
layer: 'objects',
_pageid: pageId,
name: stateCOF.activeTokenName
});
} else {
prevToken = findObjs({
_type: 'graphic',
_subtype: 'token',
layer: 'objects',
name: stateCOF.activeTokenName
});
}
prevToken.forEach(function(o) {
affectToken(o, 'statusmarkers', o.get('statusmarkers'), evt);
affectToken(o, 'aura2_radius', o.get('aura2_radius'), evt);
affectToken(o, 'aura2_color', o.get('aura2_color'), evt);
affectToken(o, 'showplayers_aura2', o.get('showplayers_aura2'), evt);
removeTokenFlagAura(o);
});
}
}
if (tokenId) {
var perso = tokenOfId(tokenId, tokenId);
if (perso) {
var token = perso.token;
var charId = perso.charId;
// personnage lié au Token
affectToken(token, 'statusmarkers', token.get('statusmarkers'), evt);
affectToken(token, 'aura2_radius', token.get('aura2_radius'), evt);
affectToken(token, 'aura2_color', token.get('aura2_color'), evt);
affectToken(token, 'showplayers_aura2', token.get('showplayers_aura2'), evt);
setTokenFlagAura(perso);
stateCOF.activeTokenId = tokenId;
stateCOF.activeTokenName = token.get('name');
turnAction(perso);
// Gestion de la confusion
if (attributeAsBool(perso, "confusion")) {
//Une chance sur deux de ne pas agir
if (randomInteger(2) < 2) {
sendChar(charId, "est en pleine confusion. Il ne fait rien ce tour");
removeTokenFlagAura(token);
} else {
//Trouver la créature la plus proche
var closestToken;
pageId = token.get('pageid');
var toksOnPage = findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId,
layer: 'objects'
});
toksOnPage.forEach(function(tok) {
if (tok.id == tokenId) return;
var perso = {
token: tok
};
perso.charId = tok.get('represents');
if (perso.charId === '') return;
if (getState(perso, 'mort')) return;
var dist = distanceCombat(token, tok, pageId);
if (closestToken) {
if (dist > closestToken.distance) return;
if (dist < closestToken.distance) {
closestToken = {
distance: dist,
names: [tok.get('name')]
};
return;
}
closestToken.names.push(tok.get('name'));
return;
}
closestToken = {
distance: dist,
names: [tok.get('name')]
};
});
if (closestToken) {
var r = randomInteger(closestToken.names.length) - 1;
sendChar(charId,
"est en pleine confusion. " + onGenre(charId, 'Il', 'Elle') +
" attaque " + closestToken.names[r] + ".");
} else {
sendChar(charId, "est seul et en plein confusion");
}
}
}
//On enlève aussi les états qui ne durent qu'un tour
var defenseTotale = tokenAttribute(perso, 'defenseTotale');
if (defenseTotale.length > 0) {
defenseTotale = defenseTotale[0];
var tourDefTotale = defenseTotale.get('max');
if (tourDefTotale < stateCOF.tour) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(defenseTotale);
defenseTotale.remove();
}
}
} else {
error("Impossible de trouver le token dont c'est le tour", tokenId);
stateCOF.activeTokenId = undefined;
}
} else stateCOF.activeTokenId = undefined;
}
function getTurnOrder(evt) {
var turnOrder = Campaign().get('turnorder');
evt.turnorder = evt.turnorder || turnOrder;
if (turnOrder === "") {
turnOrder = [{
id: "-1",
pr: 1,
custom: "Tour",
formula: "+1"
}];
evt.tour = stateCOF.tour;
stateCOF.tour = 1;
} else {
turnOrder = JSON.parse(turnOrder);
}
var indexTour = turnOrder.findIndex(function(elt) {
return (elt.id == "-1" && elt.custom == "Tour");
});
if (indexTour == -1) {
indexTour = turnOrder.length;
turnOrder.push({
id: "-1",
pr: 1,
custom: "Tour",
formula: "+1"
});
evt.tour = stateCOF.tour;
stateCOF.tour = 1;
}
var res = {
tour: turnOrder[indexTour],
pasAgi: turnOrder.slice(0, indexTour),
dejaAgi: turnOrder.slice(indexTour + 1, turnOrder.length)
};
return res;
}
function setTurnOrder(to, evt) {
if (to.pasAgi.length > 0) {
to.pasAgi.sort(function(a, b) {
if (a.id == "-1") return 1;
if (b.id == "-1") return -1;
if (a.pr < b.pr) return 1;
if (b.pr < a.pr) return -1;
// Priorité aux joueurs
// Premier critère : la barre de PV des joueurs est liée
var tokenA = getObj('graphic', a.id);
if (tokenA === undefined) return 1;
var tokenB = getObj('graphic', b.id);
if (tokenB === undefined) return -1;
if (tokenA.get('bar1_link') === '') {
if (tokenB.get('bar1_link') === '') return 0;
return 1;
}
if (tokenB.get('bar1_link') === '') return -1;
// Deuxième critère : les joueurs ont un DV
var charIdA = tokenA.get('represents');
if (charIdA === '') return 1;
var charIdB = tokenB.get('represents');
if (charIdB === '') return -1;
var persoA = {
token: tokenA,
charId: charIdA
};
var persoB = {
token: tokenB,
charId: charIdB
};
var dvA = ficheAttributeAsInt(persoA, "DV", 0);
var dvB = ficheAttributeAsInt(persoB, "DV", 0);
if (dvA === 0) {
if (dvB === 0) return 0;
return 1;
}
if (dvB === 0) return -1;
//Entre joueurs, priorité à la plus grosse sagesse
var sagA = ficheAttributeAsInt(persoA, 'SAGESSE', 10);
var sagB = ficheAttributeAsInt(persoB, 'SAGESSE', 10);
if (sagA < sagB) return 1;
if (sagB > sagA) return -1;
return 0;
});
setActiveToken(to.pasAgi[0].id, evt);
}
to.pasAgi.push(to.tour);
var turnOrder = to.pasAgi.concat(to.dejaAgi);
Campaign().set('turnorder', JSON.stringify(turnOrder));
}
function attendreInit(msg) {
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
error("La fonction !cof-attendre : rien à faire, pas de token selectionné", msg);
return;
}
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("Attendre jusqu'à quelle initiative ?", cmd);
return;
}
var newInit = parseInt(cmd[1]);
if (isNaN(newInit) || newInit < 1) {
error("On ne peut attendre que jusqu'à une initiative de 1", cmd);
newInit = 1;
}
var evt = {
type: "attente"
};
var to = getTurnOrder(evt);
iterSelected(selected, function(perso) {
var charId = perso.charId;
var token = perso.token;
if (!isActive(perso)) return;
var tokenPos =
to.pasAgi.findIndex(function(elt) {
return (elt.id == token.id);
});
if (tokenPos == -1) { // token ne peut plus agir
sendChar(charId, " a déjà agit ce tour");
return;
}
if (newInit < to.pasAgi[tokenPos].pr) {
to.pasAgi[tokenPos].pr = newInit;
sendChar(charId, " attend un peu avant d'agir...");
updateNextInit(token);
} else {
sendChar(charId, " a déjà une initiative inférieure à " + newInit);
}
});
setTurnOrder(to, evt);
addEvent(evt);
});
}
function statut(msg) { // show some character informations
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
error("Dans !cof-statut : rien à faire, pas de token selectionné", msg);
return;
}
iterSelected(selected, function(perso) {
var token = perso.token;
var charId = perso.charId;
var name = token.get('name');
var lie = true;
if (token.get('bar1_link') === '') lie = false;
var display = startFramedDisplay(playerId, "État de " + name, perso, {
chuchote: true
});
var line;
//inutile d'afficher les PVs, ils sont chuchotés
//line =
// "Points de vie : " + token.get('bar1_value') + " / ";
//if (persoEstPNJ(perso)) line += getAttrByName(charId, 'pnj_pv', 'max');
//else line += getAttrByName(charId, 'PV', 'max');
//addLineToFramedDisplay(display, line);
var manaAttr = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'PM'
}, {
caseInsensitive: true
});
var hasMana = false;
if (manaAttr.length > 0) {
var manaMax = parseInt(manaAttr[0].get('max'));
hasMana = !isNaN(manaMax) && manaMax > 0;
}
var dmTemp = parseInt(token.get('bar2_value'));
if (hasMana) {
var mana = dmTemp;
if (lie) mana = manaAttr[0].get('current');
line = "Points de mana : " + mana + " / " + manaAttr[0].get('max');
addLineToFramedDisplay(display, line);
dmTemp = attributeAsInt(perso, 'DMTEMP', 0);
} else if (lie) {
dmTemp = ficheAttributeAsInt(perso, 'DMTEMP', 0);
}
if (!isNaN(dmTemp) && dmTemp > 0) {
line = "Dommages temporaires : " + dmTemp;
addLineToFramedDisplay(display, line);
}
var ignorerLaDouleur = attributeAsInt(perso, 'ignorerLaDouleur', 0);
if (ignorerLaDouleur > 0) {
line = "a ignoré " + ignorerLaDouleur + " pv dans ce combat.";
addLineToFramedDisplay(display, line);
}
var aDV = charAttributeAsInt(perso, 'DV', 0);
if (aDV > 0) { // correspond aux PJs
var pr = pointsDeRecuperation(perso);
line =
"Points de récupération : " + pr.current + " / " + pr.max;
addLineToFramedDisplay(display, line);
if (ficheAttributeAsInt(perso, 'option_pc', 1)) {
var pc = 3;
var pc_max = 3;
var attr_pc = charAttribute(perso.charId, 'pc', {
caseInsensitive: true
});
if (attr_pc !== undefined && attr_pc.length > 0) {
pc = parseInt(attr_pc[0].get('current'));
if (isNaN(pc)) pc = 0;
pc_max = parseInt(attr_pc[0].get('max'));
if (isNaN(pc_max)) pc_max = 3;
}
line = "Points de chance : " + pc + " / " + pc_max;
addLineToFramedDisplay(display, line);
}
var pacifisme =
findObjs({
_type: "attribute",
_characterid: charId,
name: "pacifisme"
});
if (pacifisme.length > 0) {
pacifisme = parseInt(pacifisme[0].get('current'));
if (!isNaN(pacifisme)) {
if (pacifisme > 0) addLineToFramedDisplay(display, "Pacifisme actif");
else addLineToFramedDisplay(display, "Pacifisme non actif");
}
}
}
var attrsChar = findObjs({
_type: 'attribute',
_characterid: charId
});
var attrsArmes = attrsChar.filter(function(attr) {
var attrName = attr.get('name');
return (attrName.startsWith("repeating_armes_") &&
attrName.endsWith("_armenom"));
});
var armeEnMain =
attrsChar.find(function(a) {
return a.get('name') == 'armeEnMain';
});
if (armeEnMain) armeEnMain = armeEnMain.get('current');
attrsArmes.forEach(function(attr) {
var nomArme = attr.get('current');
var armeLabel = nomArme.split(' ', 1)[0];
nomArme = nomArme.substring(nomArme.indexOf(' ') + 1);
var charge = attrsChar.find(function(a) {
return (a.get('name') == 'charge_' + armeLabel);
});
if (charge) {
charge = parseInt(charge.get('current'));
if (!isNaN(charge)) {
if (charge === 0) {
line = nomArme + " n'est pas chargé";
} else {
var grenaille = attrsChar.find(function(a) {
return (a.get('name') == 'chargeGrenaille_' + armeLabel);
});
if (grenaille) {
grenaille = parseInt(grenaille.get('current'));
if (isNaN(grenaille) || grenaille < 0) grenaille = 0;
} else grenaille = 0;
if (charge == 1) {
line = nomArme + " est chargé";
if (grenaille) line += " de grenaille";
} else if (charge > 1) {
line = nomArme + " contient encore " + charge + " charges";
if (grenaille == charge) line += " de grenaille";
else if (grenaille)
line += ", dont " + grenaille + " de grenaille";
}
}
if (armeEnMain == armeLabel) line += " et en main";
else line += ", pas en main";
addLineToFramedDisplay(display, line);
}
} else if (armeEnMain == armeLabel) {
addLineToFramedDisplay(display, "tient " + nomArme + " en main.");
}
if (attributeAsBool(perso, 'poisonRapide_' + armeLabel)) {
addLineToFramedDisplay(display, nomArme + " est enduit de poison.");
}
});
if (attributeAsInt(perso, 'enflamme', 0))
addLineToFramedDisplay(display, "en flammes");
var attrEnveloppe = tokenAttribute(perso, 'enveloppePar');
if (attrEnveloppe.length > 0) {
var cube = tokenOfIdName(attrEnveloppe[0].get('current'));
if (cube) {
addLineToFramedDisplay(display, "est enveloppé dans " + cube.tokName);
}
}
var pageId = perso.token.get('pageid');
var defense = defenseOfToken(undefined, perso, pageId, undefined, {
test: true
});
var defenseMontree;
var bufDef = attributeAsInt(perso, 'bufDEF', 0);
if (bufDef > 0) {
addLineToFramedDisplay(display, "Défense temporairement modifiée de " + bufDef + " (DEF " + defense + ")");
defenseMontree = true;
}
for (var etat in cof_states) {
if (getState(perso, etat)) {
var etext = etat;
if (etext.endsWith('e')) etext = etext.substring(0, etext.length - 1) + 'é';
etext += eForFemale(charId);
var saveEtat = boutonSaveState(perso, etat);
if (saveEtat) etext += ", " + saveEtat;
addLineToFramedDisplay(display, etext);
}
}
if (ficheAttributeAsInt(perso, 'DEFARMUREON', 1) === 0) {
addLineToFramedDisplay(display, "Ne porte pas son armure");
if (charAttributeAsInt(perso, 'vetementsSacres', 0) > 0) {
addLineToFramedDisplay(display, " mais bénéficie de ses vêtements sacrés (DEF " + defense + ")");
defenseMontree = true;
}
if (charAttributeAsInt(perso, 'armureDeVent', 0) > 0) {
addLineToFramedDisplay(display, " mais bénéficie de son armure de vent (DEF " + defense + ")");
defenseMontree = true;
}
}
if (ficheAttributeAsInt(perso, 'DEFBOUCLIERON', 1) === 0 &&
ficheAttributeAsInt(perso, 'DEFBOUCLIER', 0))
addLineToFramedDisplay(display, "Ne porte pas son bouclier");
if (attributeAsBool(perso, 'etatExsangue')) {
addLineToFramedDisplay(display, "est exsangue");
}
if (attributeAsBool(perso, 'malediction')) {
addLineToFramedDisplay(display, "est maudit...");
}
var allAttrs = findObjs({
_type: 'attribute',
_characterid: charId
});
allAttrs.forEach(function(attr) {
var attrName = attr.get('name');
if (!lie && !attrName.endsWith('_' + name)) return;
if (estEffetTemp(attrName)) {
var effet = effetTempOfAttribute(attr);
var mt = messageEffetTemp[effet];
if (lie) {
if (mt.generic) {
if (attrName.indexOf(')_') > 0) return;
} else if (effet != attrName) return;
}
addLineToFramedDisplay(display, mt.actif);
} else if (estEffetCombat(attrName)) {
var effetC = effetCombatOfAttribute(attr);
if (lie && effetC != attrName) return;
addLineToFramedDisplay(display, messageEffetCombat[effetC].actif);
} else if (estEffetIndetermine(attrName)) {
var effetI = effetIndetermineOfAttribute(attr);
if (lie && effetI != attrName) return;
addLineToFramedDisplay(display, messageEffetIndetermine[effetI].actif);
}
});
allAttributesNamed(attrsChar, 'munition').forEach(function(attr) {
var attrName = attr.get('name');
var underscore = attrName.indexOf('_');
if (underscore < 0 || underscore == attrName.length - 1) return;
var munitionNom = attrName.substring(underscore + 1).replace(/_/g, ' ');
addLineToFramedDisplay(display, munitionNom + " : " + attr.get('current') + " / " + attr.get('max'));
});
var attrPosture = tokenAttribute(perso, 'postureDeCombat');
if (attrPosture.length > 0) {
attrPosture = attrPosture[0];
var posture = attrPosture.get('max');
var postureMsg = "a une posture ";
switch (posture.substr(-3, 3)) {
case 'DEF':
postureMsg += "défensive";
break;
case 'ATT':
postureMsg += "offensive";
break;
case '_DM':
postureMsg += "puissante";
break;
default:
}
postureMsg += " mais ";
switch (posture.substr(0, 3)) {
case 'DEF':
postureMsg += "risquée";
break;
case 'ATT':
postureMsg += "moins précise";
break;
case 'DM_':
postureMsg += "moins puissante";
break;
default:
}
addLineToFramedDisplay(display, postureMsg);
}
var rangSoin = charAttributeAsInt(perso, 'voieDesSoins', 0);
if (rangSoin > 0) {
var msgSoins;
var soinsRestants;
var soins = "";
var soinsLegers = charAttributeAsInt(perso, 'soinsLegers', 0);
if (soinsLegers < rangSoin) {
soinsRestants = rangSoin - soinsLegers;
if (soinsRestants > 1) soins = 's';
msgSoins = "peut encore faire " + soinsRestants + " soin" + soins + " léger" + soins;
addLineToFramedDisplay(display, msgSoins);
} else {
addLineToFramedDisplay(display, "ne peut plus faire de soin léger aujourd'hui");
}
if (rangSoin > 1) {
var soinsModeres = charAttributeAsInt(perso, 'soinsModeres', 0);
if (soinsModeres < rangSoin) {
soinsRestants = rangSoin - soinsModeres;
if (soinsRestants > 1) soins = 's';
else soins = '';
msgSoins = "peut encore faire " + soinsRestants + " soin" + soins + " modéré" + soins;
addLineToFramedDisplay(display, msgSoins);
} else {
addLineToFramedDisplay(display, "ne peut plus faire de soin modéré aujourd'hui");
}
}
}
var ebriete = attributeAsInt(perso, 'niveauEbriete', 0);
if (ebriete > 0 && ebriete < niveauxEbriete.length) {
addLineToFramedDisplay(display, "est " + niveauxEbriete[ebriete]);
}
if (!defenseMontree) {
var defenseAffichee = 10;
if (getAttrByName(perso.charId, 'type_personnage') == 'PNJ') {
defenseAffichee = ficheAttributeAsInt(perso, 'pnj_def', 10);
} else {
defenseAffichee += ficheAttributeAsInt(perso, 'DEFARMURE', 0) * ficheAttributeAsInt(perso, 'DEFARMUREON', 1);
defenseAffichee += ficheAttributeAsInt(perso, 'DEFBOUCLIER', 0) * ficheAttributeAsInt(perso, 'DEFBOUCLIERON', 1);
defenseAffichee += ficheAttributeAsInt(perso, 'DEFDIV', 0);
defenseAffichee += modCarac(perso, 'DEXTERITE');
}
if (defense != defenseAffichee)
addLineToFramedDisplay(display, "Défense actuelle : " + defense);
}
sendChat("", endFramedDisplay(display));
});
});
}
function removeFromTurnTracker(tokenId, evt) {
var turnOrder = Campaign().get('turnorder');
if (turnOrder === "" || !stateCOF.combat) {
return;
}
evt.turnorder = evt.turnorder || turnOrder;
turnOrder = JSON.parse(turnOrder).filter(
function(elt) {
return (elt.id != tokenId);
});
Campaign().set('turnorder', JSON.stringify(turnOrder));
}
function replaceInTurnTracker(tidOld, tidNew, evt) {
var turnOrder = Campaign().get('turnorder');
if (turnOrder === "" || !stateCOF.combat) {
return;
}
evt.turnorder = evt.turnorder || turnOrder;
turnOrder = JSON.parse(turnOrder);
turnOrder.forEach(function(elt) {
if (elt.id == tidOld) elt.id = tidNew;
});
Campaign().set('turnorder', JSON.stringify(turnOrder));
if (tidOld == stateCOF.activeTokenId)
stateCOF.activeTokenId = tidNew;
}
function eForFemale(charId) {
return onGenre(charId, '', 'e');
}
function armureMagique(msg) {
msg.content += " armureMagique";
effetCombat(msg);
}
function bufDef(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("La fonction !cof-buf-def attend un argument", cmd);
return;
}
var buf = parseInt(cmd[1]);
if (isNaN(buf)) {
error("Argument de !cof-bu-def invalide", cmd);
return;
}
if (buf === 0) return;
var message = "";
if (buf > 0) message = "voit sa défense augmenter";
else message = "voit sa défense baisser";
var evt = {
type: 'other'
};
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
sendPlayer(msg, "Pas de token sélectionné pour !cof--buf-def");
}
iterSelected(selected, function(perso) {
setTokenAttr(perso, 'bufDEF', buf, evt, message);
setToken(perso.token, 'status_blue', buf, evt);
});
if (evt.attributes.length === 0) {
error("Pas de cible valide sélectionnée pour !cod-buf-def", msg);
return;
}
addEvent(evt);
});
}
function removeBufDef(msg) {
var evt = {
type: 'other'
};
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
sendPlayer(msg, "Pas de token sélectionné pour !cof-remove-buf-def");
}
iterSelected(selected, function(perso) {
removeTokenAttr(perso, 'bufDEF', evt, "retrouve sa défense normale");
setToken(perso.token, 'status_blue', false, evt);
});
addEvent(evt);
});
}
//retourne un entier
// evt n'est défini que si la caractéristique est effectivement utlilisée
function bonusTestCarac(carac, personnage, evt, explications) {
explications = explications || [];
var bonus = modCarac(personnage, caracOfMod(carac));
bonus += ficheAttributeAsInt(personnage, carac + "_BONUS", 0);
if (attributeAsBool(personnage, 'chantDesHeros')) {
var bonusChantDesHeros = getValeurOfEffet(personnage, 'chantDesHeros', 1);
var chantDesHerosIntense = attributeAsInt(personnage, 'chantDesHerosTempeteDeManaIntense', 0);
bonusChantDesHeros += chantDesHerosIntense;
explications.push("Chant des héros : +" + bonusChantDesHeros + " au jet");
bonus += bonusChantDesHeros;
if (chantDesHerosIntense && evt)
removeTokenAttr(personnage, 'chantDesHerosTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'benediction')) {
var bonusBenediction = getValeurOfEffet(personnage, 'benediction', 1);
var benedictionIntense = attributeAsInt(personnage, 'benedictionTempeteDeManaIntense', 0);
bonusBenediction += benedictionIntense;
explications.push("Bénédiction : +" + bonusBenediction + " au jet");
bonus += bonusBenediction;
if (benedictionIntense && evt)
removeTokenAttr(personnage, 'benedictionTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'lameDeLigneePerdue')) {
explications.push("Lame de lignée perdue : -1 au jet");
bonus -= 1;
}
if (attributeAsBool(personnage, 'strangulation')) {
var malusStrangulation =
1 + attributeAsInt(personnage, 'dureeStrangulation', 0);
explications.push("Strangulation : -" + malusStrangulation + " au jet");
bonus -= malusStrangulation;
}
if (attributeAsBool(personnage, 'nueeDInsectes')) {
var malusNuee = 2 + attributeAsInt(personnage, 'nueeDInsectesTempeteDeManaIntense', 0);
explications.push("Nuée d'insectes : -" + malusNuee + " au jet");
bonus -= malusNuee;
if (malusNuee > 2 && evt)
removeTokenAttr(personnage, 'nueeDInsectesTempeteDeManaIntense', evt);
}
if (attributeAsBool(personnage, 'etatExsangue')) {
explications.push("Exsangue : -2 au jet");
bonus -= 2;
}
if (attributeAsBool(personnage, 'putrefactionOutrTombe')) {
explications.push("Putréfié : -2 au jet");
bonus -= 2;
}
var fortifie = attributeAsInt(personnage, 'fortifie', 0);
if (fortifie > 0) {
explications.push("Fortifié : +3 au jet");
bonus += 3;
if (evt) {
fortifie--;
if (fortifie === 0) {
removeTokenAttr(personnage, 'fortifie', evt);
} else {
setTokenAttr(personnage, 'fortifie', fortifie, evt);
}
}
}
var bonusAspectDuDemon;
switch (carac) {
case 'DEX':
var malusArmure = 0;
if (ficheAttributeAsInt(personnage, 'DEFARMUREON', 1))
malusArmure += ficheAttributeAsInt(personnage, 'DEFARMUREMALUS', 0);
if (ficheAttributeAsInt(personnage, 'DEFBOUCLIERON', 1))
malusArmure += ficheAttributeAsInt(personnage, 'DEFBOUCLIERMALUS', 0);
if (malusArmure > 0) {
explications.push("Armure : -" + malusArmure + " au jet de DEX");
bonus -= malusArmure;
}
if (attributeAsBool(personnage, 'agrandissement')) {
explications.push("Agrandi : -2 au jet de DEX");
bonus -= 2;
}
if (attributeAsBool(personnage, 'aspectDuDemon')) {
bonusAspectDuDemon = getValeurOfEffet(personnage, 'aspectDuDemon', 2);
explications.push("Aspect du démon : +" + bonusAspectDuDemon + " au jet de DEX");
bonus += bonusAspectDuDemon;
}
break;
case 'FOR':
if (attributeAsBool(personnage, 'rayonAffaiblissant')) {
explications.push("Affaibli : -2 au jet de FOR");
bonus -= 2;
}
if (attributeAsBool(personnage, 'agrandissement')) {
explications.push("Agrandi : +2 au jet de FOR");
bonus += 2;
}
if (attributeAsBool(personnage, 'aspectDuDemon')) {
bonusAspectDuDemon = getValeurOfEffet(personnage, 'aspectDuDemon', 2);
explications.push("Aspect du démon : +" + bonusAspectDuDemon + " au jet de FOR");
bonus += bonusAspectDuDemon;
}
break;
case 'CHA':
if (attributeAsBool(personnage, 'aspectDeLaSuccube')) {
var bonusAspectDeLaSuccube = getValeurOfEffet(personnage, 'aspectDeLaSuccube', 5);
explications.push("Aspect de la succube : +" + bonusAspectDeLaSuccube + " au jet de CHA");
bonus += bonusAspectDeLaSuccube;
}
break;
case 'CON':
if (attributeAsBool(personnage, 'mutationSilhouetteMassive')) {
explications.push("Silhouette massive : +5 au jet de CON");
bonus += 5;
}
if (charAttributeAsBool(personnage, 'controleDuMetabolisme')) {
var modCha = modCarac(personnage, 'CHARISME');
if (modCha > 0) {
explications.push("Controle du métabolisme : +" + modCha + " au jet de CON");
bonus += modCha;
}
}
if (attributeAsBool(personnage, 'aspectDuDemon')) {
bonusAspectDuDemon = getValeurOfEffet(personnage, 'aspectDuDemon', 2);
explications.push("Aspect du démon : +" + bonusAspectDuDemon + " au jet de CON");
bonus += bonusAspectDuDemon;
}
break;
}
return bonus;
}
function deTest(personnage, carac) {
var dice = 20;
if (estAffaibli(personnage) || getState(personnage, 'immobilise') ||
(carac == 'DEX' && getState(personnage, 'encombre')))
dice = 12;
else {
var ebriete = attributeAsInt(personnage, 'niveauEbriete', 0);
if (ebriete > 2) dice = 12;
else if (ebriete > 1 && carac != 'CON') dice = 12;
}
return dice;
}
//callback peut prendre en argument une structure avec les champs:
// - texte: Le texte du jet
// - total : Le résultat total du jet
// - echecCritique, critique pour indiquer si 1 ou 20
// - roll: le inlineroll (pour les statistiques)
function jetCaracteristique(personnage, carac, options, evt, callback) {
var token = personnage.token;
var explications = [];
var bonusCarac = bonusTestCarac(carac, personnage, evt, explications);
if (options.bonusAttrs) {
options.bonusAttrs.forEach(function(attr) {
bonusCarac += charAttributeAsInt(personnage, attr, 0);
});
}
if (options.bonus) bonusCarac += options.bonus;
var carSup = nbreDeTestCarac(carac, personnage);
var de = computeDice(personnage, {
nbDe: carSup,
carac: carac
});
var bonusText = (bonusCarac > 0) ? ' + ' + bonusCarac : (bonusCarac === 0) ? "" : ' - ' + (-bonusCarac);
var rollExpr = "[[" + de + "cs20cf1" + "]]";
sendChat("", rollExpr, function(res) {
var rolls = res[0];
var d20roll = rolls.inlinerolls[0].results.total;
var rtext = buildinline(rolls.inlinerolls[0]) + bonusText;
var rt = {
total: d20roll + bonusCarac
};
if (d20roll == 1) {
rtext += " -> échec critique";
rt.echecCritique = true;
} else if (d20roll == 20) {
rtext += " -> réussite critique";
rt.critique = true;
} else if (bonusCarac !== 0) rtext += " = " + rt.total;
rt.texte = rtext;
rt.roll = rolls.inlinerolls[0];
callback(rt, explications);
});
}
// Ne pas remplacer les inline rolls, il faut les afficher correctement
function dmgDirects(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 2) {
error("cof-dmg prend les dégats en argument, avant les options",
msg.content);
return;
}
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
sendPlayer(msg, "pas de cible trouvée, action annulée");
return;
}
var evt = {
type: 'dégâts directs',
};
if (limiteRessources(options.lanceur, options, 'dmg', 'dmg', evt)) return;
var action = "<b>Dégâts.</b>";
var optArgs = msg.content.split(' --');
var partialSave;
options.aoe = true;
optArgs.forEach(function(opt) {
opt = opt.trim().split(' ');
opt = opt.filter(function(c) {
return c !== '';
});
switch (opt[0]) {
case 'psave':
var psaveopt = options;
if (options.additionalDmg && opt.length > 3 && opt[3] == 'local') {
var psavel = options.additionalDmg.length;
if (psavel > 0) {
psaveopt = options.additionalDmg[psavel - 1];
}
}
var psaveParams = parseSave(opt);
if (psaveParams) {
psaveopt.partialSave = psaveParams;
action +=
" Jet de " + psaveParams.carac + " difficulté " + psaveParams.seuil +
" pour réduire les dégâts";
}
return;
case 'once':
if (opt.length < 2) {
error("Il manque l'id de l'événement qui a provoqué les dégâts", optArgs);
options.return = true;
return;
}
var originalEvt = findEvent(opt[1]);
if (originalEvt === undefined) {
sendPlayer(msg, "Trop tard pour les dégâts : l'action de départ est trop ancienne ou a été annulée");
options.return = true;
return;
}
if (originalEvt.waitingForAoe) {
evt = originalEvt;
// Il faudra enlever waitingForAoe à la place de faire un addEvent
return;
}
sendPlayer(msg, "Action déjà effectuée");
options.return = true;
return;
case 'asphyxie':
case 'affute':
case "metal":
case 'vampirise':
case 'magique':
case 'artificiel':
case 'tranchant':
case 'percant':
case 'contondant':
case 'tempDmg':
case 'morts-vivants':
case 'ignoreRD':
case 'ignoreMoitieRD':
case 'maxDmg':
options[opt[0]] = true;
return;
case "feu":
case "froid":
case "acide":
case "electrique":
case "sonique":
case "poison":
case "maladie":
case "argent":
if (options.additionalDmg) {
var l = options.additionalDmg.length;
if (l > 0) {
options.additionalDmg[l - 1].type = opt[0];
} else {
options.type = opt[0];
}
} else options.type = opt[0];
return;
case "nature":
case "naturel":
options.nature = true;
return;
}
});
if (options.return) return;
//L'expression à lancer est tout ce qui est entre le premier blanc et le premier --
var debutDmgRollExpr = msg.content.indexOf(' ') + 1;
var dmgRollExpr = msg.content.substring(debutDmgRollExpr);
var finDmgRollExpr = msg.content.indexOf(' --');
if (finDmgRollExpr > debutDmgRollExpr)
dmgRollExpr = msg.content.substring(debutDmgRollExpr, finDmgRollExpr);
else dmgRollExpr = msg.content.substring(debutDmgRollExpr);
dmgRollExpr = dmgRollExpr.trim();
var dmgType = options.type || 'normal';
var dmg = {
type: dmgType,
value: dmgRollExpr
};
if (options.maxDmg) {
dmgRollExpr = dmgRollExpr.replace(/d([1-9])/g, "*$1");
}
sendChat('', '[[' + dmgRollExpr + ']]', function(resDmg) {
var rollsDmg = resDmg[0];
var afterEvaluateDmg = rollsDmg.content.split(' ');
var dmgRollNumber = rollNumber(afterEvaluateDmg[0]);
dmg.total = rollsDmg.inlinerolls[dmgRollNumber].results.total;
dmg.display = buildinline(rollsDmg.inlinerolls[dmgRollNumber], dmgType, options.magique);
var display = startFramedDisplay(playerId, action);
var tokensToProcess = selected.length;
var someDmgDone;
var finalDisplay = function() {
if (tokensToProcess == 1) {
if (someDmgDone) {
sendChat("", endFramedDisplay(display));
if (evt.affectes || evt.attributes) {
if (evt.waitingForAoe) {
delete evt.waitingForAoe;
} else {
addEvent(evt);
}
}
} else {
sendPlayer(msg, "Aucune cible valide n'a été sélectionée");
}
}
tokensToProcess--;
};
iterSelected(selected, function(perso) {
if (options['morts-vivants'] && !(estMortVivant(perso))) {
sendPlayer(msg, perso.token.get('name') + " n'est pas un mort-vivant");
finalDisplay();
return;
}
var name = perso.token.get('name');
var explications = [];
perso.ignoreRD = options.ignoreRD;
perso.ignoreMoitieRD = options.ignoreMoitieRD;
perso.tempDmg = options.tempDmg;
dealDamage(perso, dmg, [], evt, false, options, explications,
function(dmgDisplay, dmgFinal) {
someDmgDone = true;
addLineToFramedDisplay(display,
name + " reçoit " + dmgDisplay + " DM");
explications.forEach(function(e) {
addLineToFramedDisplay(display, e, 80, false);
});
finalDisplay();
});
}, finalDisplay); //fin iterSelected
}); //fin du jet de dés
}, options); //fin du getSelected
}
function findRollNumber(msg) {
if (msg.length > 4) {
if (msg.substring(0, 3) == '$[[') {
var res = rollNumber(msg);
if (isNaN(res)) return undefined;
return res;
}
}
return undefined;
}
function estElementaire(t) {
if (t === undefined) return false;
return (t == "feu" || t == "froid" || t == "acide" || t == "electrique");
}
function interfaceSetState(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("Pas assez d'arguments pour !cof-set-state", msg.content);
return;
}
var etat = cmd[1];
var valeur = cmd[2];
if (valeur == "false" || valeur == "0") valeur = false;
if (valeur == "true") valeur = true;
if (!_.has(cof_states, etat)) {
error("Le premier argument de !cof-set-state n'est pas un état valide", cmd);
return;
}
var save;
if (isCarac(cmd[2])) {
if (cmd.length < 4) {
error("Il manque la difficulté du jet de sauvegarde.", cmd);
return;
}
valeur = true;
save = {
carac: cmd[2]
};
var opposition = tokenOfId(cmd[3]);
if (opposition) {
save.difficulte = cmd[3] + ' ' + opposition.token.get('name');
} else {
save.difficulte = parseInt(cmd[3]);
if (isNaN(save.difficulte)) {
error("Difficulté du jet de sauvegarde incorrecte", cmd);
return;
}
}
}
var evt = {
type: "set_state",
};
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
error("Pas de cible pour le changement d'état", msg);
return;
}
var lanceur = options.lanceur;
if (lanceur === undefined && selected.length == 1)
lanceur = tokenOfId(selected[0]._id);
if (limiteRessources(lanceur, options, etat, etat, evt)) return;
if (options.message) {
if (lanceur) sendChar(lanceur.charId, options.message);
else sendChat('', options.message);
}
iterSelected(selected, function(perso) {
setState(perso, etat, valeur, evt);
if (save) {
setTokenAttr(perso, etat + 'Save', save.carac, evt, undefined, save.difficulte);
}
});
addEvent(evt);
});
}
function textOfSaveState(etat) {
switch (etat) {
case 'immobilise':
return "se libérer";
case 'aveugle':
return "retrouver la vue";
case 'etourdi':
return "reprendre ses esprits";
case 'assome':
return "reprendre conscience";
case 'renverse':
return "se relever";
case 'endormi':
return "se réveiller";
case 'apeure':
return "retrouver du courage";
default:
return "ne plus être " + etat;
}
}
function saveState(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 4 ||
!_.has(cof_states, cmd[1]) || !isCarac(cmd[2])) {
error("Paramètres de !cof-save-state incorrects", cmd);
return;
}
var etat = cmd[1];
var carac = cmd[2];
var titre = 'Jet de ' + carac + ' pour ' + textOfSaveState(etat);
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
error("Pas de token sélectionné", msg.content);
return;
}
var pageId = options.pageId;
if (pageId === undefined) {
iterSelected(selected, function(perso) {
if (pageId) return;
pageId = perso.token.get('pageid');
});
}
var opposant = tokenOfId(cmd[3], cmd[4], pageId);
if (opposant) {
iterSelected(selected, function(perso) {
if (!getState(perso, etat)) {
sendChar(perso.charId, "n'est pas " + etat + eForFemale(perso.charId));
return;
}
var evt = {
type: titre
};
var display = startFramedDisplay(playerId, titre, perso, {
perso2: opposant
});
var explications = [];
testOppose(perso, carac, opposant, carac, explications, evt,
function(resultat, crit) {
if (resultat == 2) {
explications.push(perso.token.get('name') + " est toujours " + etat + eForFemale(perso.charId));
} else {
setState(perso, etat, false, evt);
explications.push(perso.token.get('name') + " n'est plus " + etat + eForFemale(perso.charId));
}
explications.forEach(function(e) {
addLineToFramedDisplay(display, e);
});
addEvent(evt);
sendChat("", endFramedDisplay(display));
}); //fin test opposé (asynchrone)
}); //fin iterSelected du cas avec opposant
} else {
var seuil = parseInt(cmd[3]);
if (isNaN(seuil)) {
error("La difficulté n'est pas un nombre", cmd);
return;
}
iterSelected(selected, function(perso) {
if (!getState(perso, etat)) {
sendChar(perso.charId, "n'est pas " + etat + eForFemale(perso.charId));
return;
}
var evt = {
type: titre
};
testCaracteristique(perso, carac, seuil, {}, evt, function(res) {
sendChar(perso.charId, titre + " : " + res.texte);
if (res.reussite) {
setState(perso, etat, false, evt);
sendChar(perso.charId, res.texte + " ≥ " + seuil + ", " + perso.token.get('name') + " n'est plus " + etat + eForFemale(perso.charId));
} else {
sendChar(perso.charId, res.texte + " < " + seuil + ", " + perso.token.get('name') + " est toujours " + etat + eForFemale(perso.charId));
}
addEvent(evt);
}); //fin test carac
}); //fin iterSelected du cas sans opposant
}
}); //fin getSelected
}
//Renvoie false si le personnage n'a pas d'attribut etatSave
function boutonSaveState(perso, etat) {
var attr = tokenAttribute(perso, etat + 'Save');
if (attr.length === 0) return false;
attr = attr[0];
var carac = attr.get('current');
if (!isCarac(carac)) {
log("Caractéristiques du save contre " + etat + " de " + perso.token.get('name') + " n'est pas une caractéristique " + carac);
return false;
}
var b = bouton("!cof-save-state " + etat + ' ' + carac + ' ' + attr.get('max'), "Jet", perso);
return b + " de " + carac + " pour " + textOfSaveState(etat);
}
function updateInit(token, evt) {
if (stateCOF.combat &&
token.get('pageid') == stateCOF.combat_pageid)
initiative([{
_id: token.id
}], evt, true);
}
function updateNextInit(token) {
updateNextInitSet.add(token.id);
}
//renvoie le nom de l'arme si l'arme est déjà tenue en main
function degainerArme(perso, labelArme, evt, options) {
//D'abord, on rengaine l'arme en main, si besoin.
var armeActuelle = tokenAttribute(perso, 'armeEnMain');
var labelArmeActuelle;
var ancienneArme;
var message = perso.token.get('name') + " ";
if (armeActuelle.length > 0) {
armeActuelle = armeActuelle[0];
labelArmeActuelle = armeActuelle.get('current');
if (labelArmeActuelle == labelArme) {
//Pas besoin de dégainer. Pas de message ?
if (options && options.weaponStats) return options.weaponStats.name;
ancienneArme = getWeaponStats(perso, labelArmeActuelle);
if (ancienneArme) return ancienneArme.name;
return;
}
//On dégaine une nouvelle arme
ancienneArme = getWeaponStats(perso, labelArmeActuelle);
if (ancienneArme) {
if (options && options.messages) message += "rengaine " + ancienneArme.name + " et ";
else sendChar(perso.charId, "rengaine " + ancienneArme.name);
}
} else armeActuelle = undefined;
//Puis on dégaine
//On vérifie que l'arme existe
var nouvelleArme;
if (options && options.weaponStats) nouvelleArme = options.weaponStats;
else if (labelArme !== '') nouvelleArme = getWeaponStats(perso, labelArme);
if (nouvelleArme === undefined) {
if (armeActuelle) {
removeTokenAttr(perso, 'armeEnMain', evt);
if (!stateCOF.combat) {
//Si le perso a la capacité frappe du vide, la réinitialiser
var attrFDV = tokenAttribute(perso, 'frappeDuVide');
if (attrFDV.length > 0) {
if (!attrFDV[0].get('current')) {
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: attrFDV[0],
current: 0,
max: 1
});
attrFDV[0].set('current', 1);
}
}
}
}
return;
}
if (nouvelleArme.deuxMains) {
if (ficheAttributeAsBool(perso, 'DEFBOUCLIER') &&
ficheAttributeAsInt(perso, 'DEFBOUCLIERON', 1)) {
sendChar(perso.charId, "enlève son bouclier");
var attrBouclier = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: 'DEFBOUCLIERON'
}, {
caseInsensistive: true
});
evt.attributes = evt.attributes || [];
if (attrBouclier.length > 0) {
evt.attributes.push({
attribute: attrBouclier[0],
current: 1,
max: ''
});
attrBouclier[0].set('current', 0);
} else {
attrBouclier = createObj('attribute', {
characterid: perso.charId,
name: 'DEFBOUCLIERON',
current: 0
});
evt.attributes.push({
attribute: attrBouclier,
current: null
});
}
}
} else if (ancienneArme && ancienneArme.deuxMains) {
if (ficheAttributeAsBool(perso, 'DEFBOUCLIER') &&
!ficheAttributeAsInt(perso, 'DEFBOUCLIERON', 1)) {
sendChar(perso.charId, "remet son bouclier");
evt.attributes = evt.attributes || [];
var attrBouclierOff = findObjs({
_type: 'attribute',
_characterid: perso.charId,
name: 'DEFBOUCLIERON'
}, {
caseInsensistive: true
}); //devrait être de taille au moins 1, avec valeur courante 0
evt.attributes.push({
attribute: attrBouclierOff[0],
current: 0,
max: ''
});
attrBouclierOff[0].set('current', 1);
}
}
if (attributeAsBool(perso, 'frappeDuVide')) {
if (options && options.contact) {
options.frappeDuVide = true;
}
setTokenAttr(perso, 'frappeDuVide', 0, evt);
}
if (armeActuelle) {
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: armeActuelle,
current: labelArmeActuelle,
max: ''
});
armeActuelle.set('current', labelArme);
} else {
setTokenAttr(perso, 'armeEnMain', labelArme, evt);
}
if (options && options.messages) {
message += "dégaine " + nouvelleArme.name;
options.messages.push(message);
} else sendChar(perso.charId, "dégaine " + nouvelleArme.name);
if (charAttributeAsInt(perso, "initEnMain" + labelArme, 0) > 0)
updateNextInit(perso.token);
}
function degainer(msg) {
var cmd = msg.content.split(' ');
var armeLabel = '';
if (cmd.length > 1) armeLabel = cmd[1];
var evt = {
type: "Dégainer",
attributes: []
};
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
error("Qui doit dégainer ?", msg);
return;
}
iterSelected(selected, function(perso) {
var nomArme = degainerArme(perso, armeLabel, evt);
if (nomArme) sendChar(perso.charId, "a déjà " + nomArme + " en main");
});
if (evt.attributes.length > 0) addEvent(evt);
});
}
function echangeInit(msg) {
var args = msg.content.split(" ");
if (args.length < 4) {
error("Pas assez d'arguments pour !cof-echange-init: " + msg.content, args);
return;
}
var perso1 = tokenOfId(args[1], args[1]);
if (perso1 === undefined) {
error("le premier argument n'est pas un token valide", args[1]);
return;
}
var perso2 = tokenOfId(args[2], args[2]);
if (perso2 === undefined) {
error("le second argument n'est pas un token valide", args[2]);
return;
}
var attackBonus = parseInt(args[3]);
if (isNaN(attackBonus) || attackBonus < 1 || attackBonus > 2) {
error("Le troisième argument n'est pas un nombre", args[3]);
return;
}
var evt = {
type: "echange_init"
};
var to = getTurnOrder(evt);
var tourTok1 = to.pasAgi.findIndex(function(t) {
return (t.id == perso1.token.id);
});
var tourTok2 = to.pasAgi.findIndex(function(t) {
return (t.id == perso2.token.id);
});
if (tourTok1 < 0) {
sendChar(perso1.charId, "a déjà agit, pas moyen d'échanger son initiative");
return;
}
if (tourTok2 < 0) {
sendChar(perso2.charId, "a déjà agit, pas moyen d'échanger son initiative");
return;
}
var pr1 = to.pasAgi[tourTok1].pr;
var pr2 = to.pasAgi[tourTok2].pr;
if (pr1 == pr2) {
sendChar(perso1.charId, "a la même initiative que " + perso2.token.get('name'));
return;
}
if (pr1 > pr2) {
setTokenAttr(perso1, 'actionConcertee', attackBonus, evt, "gagne un bonus de " + attackBonus + " à ses attaques et en DEF pour ce tour");
addEvent(evt);
}
to.pasAgi[tourTok1].pr = pr2;
to.pasAgi[tourTok2].pr = pr1;
var t1 = to.pasAgi[tourTok1];
to.pasAgi[tourTok1] = to.pasAgi[tourTok2];
to.pasAgi[tourTok2] = t1;
updateNextInit(perso1.token);
updateNextInit(perso2.token);
to.pasAgi.push(to.tour);
var turnOrder = to.pasAgi.concat(to.dejaAgi);
Campaign().set('turnorder', JSON.stringify(turnOrder));
addEvent(evt);
}
function aCouvert(msg) {
var args = msg.content.split(" ");
if (args.length < 2) {
error("Pas assez d'arguments pour !cof-a-couvert: " + msg.content, args);
return;
}
var perso1 = tokenOfId(args[1], args[1]);
if (perso1 === undefined) {
error("Le premier argument n'est pas un token valide", args[1]);
return;
}
var evt = {
type: "aCouvert"
};
var init = getInit();
setTokenAttr(perso1, 'aCouvert', 1, evt, "reste à couvert", init);
if (args.length > 2) {
var perso2 = tokenOfId(args[2], args[2]);
if (perso2 === undefined) {
error("Le second argument n'est pas un token valide", args[2]);
addEvent(evt);
return;
}
if (perso2.token.id == perso1.token.id) {
sendChar(perso1.charId, "s'est ciblé lui-même, il est donc le seul à couvert");
addEvent(evt);
return;
}
var d = distanceCombat(perso1.token, perso2.token);
if (d > 0) {
sendChar(perso2.charId, "est trop éloigné de " + perso1.token.get('name') + " pour rester à couvert avec lui");
} else {
setTokenAttr(perso2, 'aCouvert', 1, evt,
"suit " + perso1.token.get('name') + " et reste à couvert", init);
}
}
addEvent(evt);
}
function getInit() {
return stateCOF.init;
}
function effetTemporaire(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("Pas assez d'arguments pour !cof-effet-temp", msg.content);
return;
}
var effetC = cmd[1];
if (!estEffetTemp(effetC)) {
error(effetC + " n'est pas un effet temporaire répertorié", msg.content);
return;
}
var effet = cmd[1];
var pp = effet.indexOf('(');
if (pp > 0) effet = effet.substring(effet, pp);
var mEffet = messageEffetTemp[effet];
if (mEffet === undefined) {
error("Impossible de trouver l'effet " + effetC, cmd);
return;
}
var duree = parseInt(cmd[2]);
if (isNaN(duree) || duree < 1) duree = 0; //On veut terminer l'effet
if (options.puissantDuree || options.tempeteDeManaDuree) duree = duree * 2;
var evt = {
type: 'Effet temporaire ' + effetC
};
var lanceur = options.lanceur;
var charId;
if (lanceur) charId = lanceur.charId;
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
sendChar(charId, "Pas de cible sélectionée pour l'effet");
return;
}
if (lanceur === undefined) {
if (options.portee) {
error("Impossible de savoir l'origine de l'effet", options);
return;
}
if (selected.length == 1) {
lanceur = tokenOfId(selected[0]._id);
if (lanceur) charId = lanceur.charId;
}
}
if (lanceur && options.tempeteDeMana) {
if (options.tempeteDeMana.cout === 0) {
//On demande de préciser les options
var optMana = {
mana: options.mana,
dm: mEffet.dm,
soins: mEffet.soins,
portee: options.portee,
duree: true,
rang: options.rang,
altruiste: options.altruiste
};
setTempeteDeMana(playerId, lanceur, msg.content, optMana);
return;
} else {
if (options.rang && options.tempeteDeMana.cout > options.rang) {
sendChar(lanceur.charId, "Attention, le coût de la tempête de mana (" + options.tempeteDeMana.cout + ") est supérieur au rang du sort");
}
if (selected.length == 1 && options.tempeteDeMana.altruiste) {
selected[0]._id = options.tempeteDeMana.altruiste.token.id;
if (options.portee === undefined) options.portee = 0;
}
}
}
if (options.portee !== undefined) {
if (options.tempeteDeManaPortee) options.portee = options.portee * 2;
selected = selected.filter(function(sel) {
var token = getObj('graphic', sel._id);
var dist = distanceCombat(lanceur.token, token);
if (dist > options.portee) {
sendChar(charId, " est trop loin de " + token.get('name'));
return false;
}
return true;
});
}
var ressource;
if (options.limiteCibleParJour) {
ressource = effet;
if (options.limiteCibleParJourRessource)
ressource = options.limiteCibleParJourRessource;
ressource = "limiteParJour_" + ressource;
var selectedAutorises = [];
iterSelected(selected, function(perso) {
var utilisations =
attributeAsInt(perso, ressource, options.limiteCibleParJour);
if (utilisations === 0) {
sendChar(perso.charId, "ne peut plus bénéficier de " + effet + " aujourd'hui");
return;
}
setTokenAttr(perso, ressource, utilisations - 1, evt);
selectedAutorises.push({
_id: perso.token.id
});
});
selected = selectedAutorises;
}
if (selected.length === 0) return;
if (limiteRessources(lanceur, options, effet, effet, evt)) {
//Restore limiteCibleParJour
if (options.limiteCibleParJour) {
iterSelected(selected, function(perso) {
var utilisations =
attributeAsInt(perso, ressource, options.limiteCibleParJour);
setTokenAttr(perso, ressource, utilisations + 1, evt);
});
}
return;
}
if (selected.length > 0) {
initiative(selected, evt);
}
if (duree > 0) {
var count = selected.length;
var setOneEffect = function(perso, d) {
if (options.valeur !== undefined) {
setTokenAttr(perso, effetC + "Valeur", options.valeur, evt, undefined, options.valeurMax);
}
switch (effetC) { //effets supplémentaires associés
case 'aspectDuDemon':
//On retire l'autre aspect du Nécromancien si il est présent
finDEffetDeNom(perso, "aspectDeLaSuccube", evt);
break;
case 'aspectDeLaSuccube':
finDEffetDeNom(perso, "aspectDuDemon", evt);
break;
case 'aveugleTemp':
setState(perso, 'aveugle', true, evt);
break;
case 'ralentiTemp':
setState(perso, 'ralenti', true, evt);
break;
case 'paralyseTemp':
setState(perso, 'paralyse', true, evt);
break;
case 'etourdiTemp':
setState(perso, 'etourdi', true, evt);
break;
case 'affaibliTemp':
setState(perso, 'affaibli', true, evt);
break;
default:
}
if (mEffet.statusMarker) {
affectToken(perso.token, 'statusmarkers', perso.token.get('statusmarkers'), evt);
perso.token.set('status_' + mEffet.statusMarker, true);
}
setTokenAttr(
perso, effetC, d, evt, mEffet.activation,
getInit());
if (options.saveParTour) {
setTokenAttr(perso, effetC + "SaveParTour",
options.saveParTour.carac, evt, undefined, options.saveParTour.seuil);
}
if (options.puissant) {
var puissant = true;
if (options.puissant == "off") puissant = false;
setTokenAttr(perso, effetC + "Puissant", puissant, evt);
}
if (options.tempeteDeManaIntense !== undefined) {
setTokenAttr(perso, effetC + "TempeteDeManaIntense", options.tempeteDeManaIntense, evt);
}
if (lanceur && options.fx) {
var p1e = {
x: lanceur.token.get('left'),
y: lanceur.token.get('top'),
};
var p2e = {
x: perso.token.get('left'),
y: perso.token.get('top'),
};
spawnFxBetweenPoints(p1e, p2e, options.fx, options.pageId);
}
if (options.targetFx) {
spawnFx(perso.token.get('left'), perso.token.get('top'), options.targetFx, options.pageId);
}
count--;
if (count === 0) addEvent(evt);
};
iterSelected(selected, function(perso) {
if (options.save) {
var saveOpts = {
msgPour: " pour résister à un effet",
msgRate: ", raté.",
};
var expliquer = function(s) {
sendChar(perso.charId, s);
};
var d = duree;
save(options.save, perso, expliquer, saveOpts, evt,
function(reussite, rollText) {
if (reussite && options.save.demiDuree) {
reussite = false;
d = Math.ceil(d / 2);
}
if (reussite) {
count--;
if (count === 0) addEvent(evt);
} else {
setOneEffect(perso, d);
}
});
} else setOneEffect(perso, duree);
});
addEvent(evt);
} else { //On met fin à l'effet
var opt = {
pageId: options.pageId
};
iterSelected(selected, function(perso) {
var attr = tokenAttribute(perso, effetC);
if (attr.length === 0) {
log(perso.token.get('name') + " n'a pas d'attribut " + effetC);
return;
}
finDEffet(attr[0], effetC, attr[0].get('name'), perso.charId, evt, opt);
});
addEvent(evt);
}
}, options);
}
function effetCombat(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 2) {
error("Pas assez d'arguments pour !cof-effet-combat", msg.content);
return;
}
var effet = cmd[1];
if (!estEffetCombat(effet)) {
error(effet + " n'est pas un effet de combat répertorié", msg.content);
return;
}
var evt = {
type: 'Effet ' + effet
};
var lanceur = options.lanceur;
var charId;
if (lanceur) charId = lanceur.charId;
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
sendChar(charId, "Pas de cible sélectionée pour l'effet");
return;
}
if (lanceur === undefined) {
if (options.portee) {
error("Impossible de savoir l'origine de l'effet", options);
return;
}
if (selected.length == 1) {
lanceur = tokenOfId(selected[0]._id);
if (lanceur) charId = lanceur.charId;
}
}
if (lanceur && options.tempeteDeMana) {
if (options.tempeteDeMana.cout === 0) {
//On demande de préciser les options
var optMana = {
mana: options.mana,
dm: messageEffetCombat[effet].dm,
soins: messageEffetCombat[effet].soins,
portee: options.portee,
altruiste: options.altruiste,
rang: options.rang
};
setTempeteDeMana(playerId, lanceur, msg.content, optMana);
return;
} else {
if (options.rang && options.tempeteDeMana.cout > options.rang) {
sendChar(lanceur.charId, "Attention, le coût de la tempête de mana (" + options.tempeteDeMana.cout + ") est supérieur au rang du sort");
}
if (selected.length == 1 && options.tempeteDeMana.altruiste) {
selected[0]._id = options.tempeteDeMana.altruiste.token.id;
if (options.portee === undefined) options.portee = 0;
}
}
}
if (options.portee !== undefined) {
if (options.tempeteDeManaPortee) options.portee = options.portee * 2;
selected = selected.filter(function(sel) {
var token = getObj('graphic', sel._id);
var dist = distanceCombat(lanceur.token, token);
if (dist > options.portee) {
sendChar(charId, " est trop loin de " + token.get('name'));
return false;
}
return true;
});
}
if (selected.length === 0) return;
if (limiteRessources(lanceur, options, effet, effet, evt)) return;
if (selected.length > 0) {
initiative(selected, evt);
}
iterSelected(selected, function(perso) {
setTokenAttr(
perso, effet, true, evt, messageEffetCombat[effet].activation);
if (options.puissant) {
var puissant = true;
if (options.puissant == "off") puissant = false;
setTokenAttr(perso, effet + "Puissant", puissant, evt);
}
if (options.valeur !== undefined) {
setTokenAttr(perso, effet + "Valeur", options.valeur, evt, undefined, options.valeurMax);
}
if (options.tempeteDeManaIntense !== undefined) {
setTokenAttr(perso, effet + "TempeteDeManaIntense", options.tempeteDeManaIntense, evt);
}
});
addEvent(evt);
if (lanceur && options.fx) {
iterSelected(selected, function(target) {
var p1e = {
x: lanceur.token.get('left'),
y: lanceur.token.get('top'),
};
var p2e = {
x: target.token.get('left'),
y: target.token.get('top'),
};
spawnFxBetweenPoints(p1e, p2e, options.fx, options.pageId);
});
}
if (options.targetFx) {
iterSelected(selected, function(target) {
spawnFx(target.token.get('left'), target.token.get('top'), options.targetFx, options.pageId);
});
}
});
}
function effetIndetermine(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("Pas assez d'arguments pour !cof-effet", msg.content);
return;
}
var effet = cmd[1];
if (!estEffetIndetermine(effet)) {
error(effet + " n'est pas un effet répertorié", msg.content);
return;
}
var activer;
switch (cmd[2]) {
case 'oui':
case 'Oui':
case 'true':
activer = true;
break;
case 'non':
case 'Non':
case 'false':
activer = false;
break;
default:
error("Option de !cof-effet inconnue", cmd);
return;
}
var evt = {
type: 'Effet ' + effet
};
var lanceur = options.lanceur;
var charId;
if (lanceur) charId = lanceur.charId;
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
sendChar(charId, "Pas de cible sélectionée pour l'effet");
return;
}
if (lanceur === undefined) {
if (options.portee) {
error("Impossible de savoir l'origine de l'effet", options);
return;
}
if (selected.length == 1) {
lanceur = tokenOfId(selected[0]._id);
if (lanceur) charId = lanceur.charId;
}
}
if (options.portee !== undefined) {
selected = selected.filter(function(sel) {
var token = getObj('graphic', sel._id);
var dist = distanceCombat(lanceur.token, token);
if (dist > options.portee) {
sendChar(charId, " est trop loin de " + token.get('name'));
return false;
}
return true;
});
}
if (selected.length === 0) return;
if (activer) {
if (limiteRessources(lanceur, options, effet, effet, evt)) return;
if (options.classeEffet) {
selected = selected.filter(function(sel) {
var perso = tokenOfId(sel._id);
if (perso === undefined) return false;
if (attributeAsBool(perso, options.classeEffet)) {
var attrDeClasse = attributesOfClass(perso, options.classeEffet);
var mpc = "Non cumulable avec";
attrDeClasse.forEach(function(attrClasseEffet) {
var attr = attrClasseEffet.baseAttribute;
var attrName = attr.get('name');
if (estEffetIndetermine(attrName))
mpc += ' ' + messageEffetIndetermine[effetIndetermineOfAttribute(attr)].actif;
else mpc += ' ' + attrName;
});
sendChar(perso.charId, mpc);
return false;
}
setTokenAttr(perso, options.classeEffet, true, evt);
setTokenAttr(perso, effet + 'ClasseEffet', options.classeEffet, evt);
return true;
});
}
iterSelected(selected, function(perso) {
setTokenAttr(
perso, effet, true, evt, messageEffetIndetermine[effet].activation);
if (options.puissant) {
var puissant = true;
if (options.puissant == "off") puissant = false;
setTokenAttr(perso, effet + "Puissant", puissant, evt);
}
if (options.tempeteDeManaIntense !== undefined) {
setTokenAttr(perso, effet + "TempeteDeManaIntense", options.tempeteDeManaIntense, evt);
}
});
} else {
iterSelected(selected, function(perso) {
//On commence par enlever les attributs de classe d'effet, si besoin
var ace = tokenAttribute(perso, effet + 'ClasseEffet');
if (ace.length > 0) {
var ce = ace[0].get('current');
removeTokenAttr(perso, ce, evt);
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(ace[0]);
ace[0].remove();
}
removeTokenAttr(perso, effet, evt, messageEffetIndetermine[effet].fin);
});
}
addEvent(evt);
});
}
function finClasseDEffet(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("Il manque l'argument de !cof-fin-classe-effet", cmd);
return;
}
var classeEffet = cmd[1];
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
error("Pas de cible sélectionnée pour la fin d'une classe d'effets", msg);
return;
}
var evt = {
type: "Fin des effets de classe " + classeEffet,
deletedAttributes: []
};
iterSelected(selected, function(perso) {
if (attributeAsBool(perso, classeEffet)) {
var attrDeClasse = attributesOfClass(perso, classeEffet);
attrDeClasse.forEach(function(adc) {
var attrName = adc.baseAttribute.get('name');
if (estEffetIndetermine(attrName))
sendChar(perso.charId, messageEffetIndetermine[effetIndetermineOfAttribute(adc.baseAttribute)].fin);
evt.deletedAttributes.push(adc.baseAttribute);
adc.baseAttribute.remove();
evt.deletedAttributes.push(adc.classAttribute);
adc.classAttribute.remove();
});
removeTokenAttr(perso, classeEffet, evt);
}
});
addEvent(evt);
}); //fin de getSelected
}
function peurOneToken(target, pageId, difficulte, duree, options,
messages, evt, callback) {
var charId = target.charId;
var targetName = target.token.get('name');
if (charAttributeAsBool(target, 'sansPeur') ||
charAttributeAsBool(target, 'immunitePeur') ||
charAttributeAsBool(target, 'proprioception') ||
attributeAsBool(target, 'enragé')) {
messages.push(targetName + " est insensible à la peur !");
callback();
return;
}
var carac = 'SAG'; //carac pour résister
if (options.resisteAvecForce)
carac = meilleureCarac('SAG', 'FOR', target, difficulte);
//chercher si un partenaire a sansPeur pour appliquer le bonus
var allieSansPeur = 0;
var allies = alliesParPerso[target.charId];
if (allies) {
allies.forEach(function(cid) {
if (charIdAttributeAsBool(cid, 'sansPeur')) {
allieSansPeur =
Math.max(allieSansPeur, 2 + modCarac(cid, 'CHARISME'));
}
});
}
testCaracteristique(target, carac, difficulte, {
bonus: allieSansPeur
}, evt,
function(tr) {
var line = "Jet de résistance de " + targetName + " :" + tr.texte;
var sujet = onGenre(charId, 'il', 'elle');
if (tr.reussite) {
line += ">=" + difficulte + ", " + sujet + " résiste à la peur.";
} else {
setState(target, 'apeure', true, evt);
line += "<" + difficulte + ", " + sujet + ' ';
var effet = 'peur';
if (options.etourdi) {
line += "s'enfuit ou reste recroquevillé" + eForFemale(charId) + " sur place";
effet = 'peurEtourdi';
} else if (options.ralenti) {
line += "est ralenti" + eForFemale(charId);
effet = 'ralentiTemp';
} else {
line += "s'enfuit.";
}
setTokenAttr(target, effet, duree, evt, undefined, getInit());
}
messages.push(line);
callback();
}); //fin testCaracteristique (asynchrone)
}
function peur(msg) {
var optArgs = msg.content.split(' --');
var cmd = optArgs[0].split(' ');
if (cmd.length < 3) {
error("Pas assez d'arguments pour !cof-peur", msg.content);
return;
}
var playerId = getPlayerIdFromMsg(msg);
var pageId = getPageId(playerId);
var difficulte = parseInt(cmd[1]);
if (isNaN(difficulte)) {
error("Le premier argument de !cof-peur, la difficulté du test de résistance, n'est pas un nombre", cmd);
return;
}
var duree = parseInt(cmd[2]);
if (isNaN(duree) || duree < 0) {
error("Le second argument de !cof-peur, la durée, n'est pas un nombre positif", cmd);
return;
}
var options = {};
optArgs.shift();
optArgs.forEach(function(opt) {
var optCmd = opt.split(' ');
switch (optCmd[0]) {
case "attaqueMagique":
error("TODO", opt);
return;
case "resisteAvecForce":
case "etourdi":
case "ralenti":
case "effroi":
options[optCmd[0]] = true;
return;
case "portee":
if (optCmd.length < 2) {
error("Il manque l'argument de portée", optArgs);
return;
}
options.portee = parseInt(optCmd[1]);
if (isNaN(options.portee) || options.portee < 0) {
error("La portée n'est pas un nombre positif", optCmd);
delete options.portee;
}
return;
case 'lanceur':
if (optCmd.length < 2) {
error("Il manque l'argument de lanceur", optArgs);
return;
}
options.lanceur = tokenOfId(optCmd[1], optCmd[1]);
if (options.lanceur) pageId = options.lanceur.token.get('pageid');
return;
default:
return;
}
});
getSelected(msg, function(selected) {
if (selected === undefined || selected.length === 0) {
error("Pas de cible sélectionnée pour la peur", msg);
return;
}
var action = "Effet de peur";
if (options.lanceur) {
action = "<b>" + options.lanceur.token.get('name') + "</b> ";
if (options.effroi)
action += "est vraiment effrayant" + eForFemale(options.lanceur.charId);
else action = "<b>Capacité</b> : Sort de peur";
}
var display = startFramedDisplay(playerId, action, options.lanceur);
var evt = {
type: 'peur'
};
initiative(selected, evt);
var counter = selected.length;
var messages = [];
var finalEffect = function() {
counter--;
if (counter > 0) return;
messages.forEach(function(m) {
addLineToFramedDisplay(display, m);
});
sendChat("", endFramedDisplay(display));
addEvent(evt);
};
iterSelected(selected, function(perso) {
if (options.portee !== undefined && options.lanceur) {
var distance = distanceCombat(options.lanceur.token, perso.token, pageId);
if (distance > options.portee) {
addLineToFramedDisplay(display,
perso.token.get('name') + " est hors de portée de l'effet");
finalEffect();
return;
}
}
peurOneToken(perso, pageId, difficulte, duree, options,
messages, evt, finalEffect);
}, //fun fonction de iterSelectde
finalEffect //callback pour les cas où token incorrect
);
}, options);
}
// callback est seulement appelé si on fait le test
function attaqueMagique(msg, evt, defResource, callback) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd.length < 3) {
error("Pas assez d'arguments pour " + msg.content, cmd);
return;
}
var attaquant = tokenOfId(cmd[1], cmd[1]);
if (attaquant === undefined) {
error("L'attaquant n'est pas un token valide", cmd[1]);
return;
}
var token1 = attaquant.token;
var charId1 = attaquant.charId;
var char1 = getObj("character", attaquant.charId);
if (char1 === undefined) {
error("Unexpected undefined 1", attaquant);
return;
}
var name1 = char1.get('name');
var pageId = attaquant.token.get('pageid');
var cible = tokenOfId(cmd[2], cmd[2], pageId);
if (cible === undefined) {
error("La cible n'est pas un token valide" + msg.content, cmd[2]);
return;
}
var token2 = cible.token;
var charId2 = cible.charId;
var char2 = getObj("character", charId2);
if (char2 === undefined) {
error("Unexpected undefined 1", token2);
return;
}
var name2 = char2.get('name');
var explications = [];
evt = evt || {
type: 'Attaque magique'
};
if (options.portee !== undefined) {
var distance = distanceCombat(token1, token2, pageId);
if (distance > options.portee) {
sendChar(charId1, "est trop loin de " + cible.token.get('name') +
" pour l'attaque magique");
return;
}
}
defResource = defResource || 'attaqueMagique';
if (limiteRessources(attaquant, options, defResource, "l'attaque magique", evt)) return;
var bonus1 = bonusDAttaque(attaquant, explications, evt);
if (bonus1 === 0) bonus1 = "";
else if (bonus1 > 0) bonus1 = " +" + bonus1;
var attk1 = addOrigin(name1, "[[" + computeArmeAtk(attaquant, '@{ATKMAG}') +
bonus1 + "]]");
var bonus2 = bonusDAttaque(cible, explications, evt);
if (bonus2 === 0) bonus2 = "";
else if (bonus2 > 0) bonus2 = " +" + bonus2;
var attk2 = addOrigin(name2, "[[" + computeArmeAtk(cible, '@{ATKMAG}') +
bonus1 + "]]");
var de1 = computeDice(attaquant);
var de2 = computeDice(cible);
var toEvaluate = "[[" + de1 + "]] [[" + de2 + "]] " + attk1 + " " + attk2;
sendChat("", toEvaluate, function(res) {
var rolls = res[0];
// Determine which roll number correspond to which expression
var afterEvaluate = rolls.content.split(" ");
var att1RollNumber = rollNumber(afterEvaluate[0]);
var att2RollNumber = rollNumber(afterEvaluate[1]);
var attk1SkillNumber = rollNumber(afterEvaluate[2]);
var attk2SkillNumber = rollNumber(afterEvaluate[3]);
var d20roll1 = rolls.inlinerolls[att1RollNumber].results.total;
var att1Skill = rolls.inlinerolls[attk1SkillNumber].results.total;
var attackRoll1 = d20roll1 + att1Skill;
var d20roll2 = rolls.inlinerolls[att2RollNumber].results.total;
var att2Skill = rolls.inlinerolls[attk2SkillNumber].results.total;
var attackRoll2 = d20roll2 + att2Skill;
var action = "Attaque magique opposée";
var display = startFramedDisplay(getPlayerIdFromMsg(msg), action, attaquant, {
perso2: cible
});
var line =
token1.get('name') + " fait " +
buildinline(rolls.inlinerolls[att1RollNumber]);
if (att1Skill > 0) line += "+" + att1Skill + " = " + attackRoll1;
else if (att1Skill < 0) line += att1Skill + " = " + attackRoll1;
addLineToFramedDisplay(display, line);
line =
token2.get('name') + " fait " +
buildinline(rolls.inlinerolls[att2RollNumber]);
if (att2Skill > 0) line += "+" + att2Skill + " = " + attackRoll2;
else if (att2Skill < 0) line += att2Skill + " = " + attackRoll2;
addLineToFramedDisplay(display, line);
var reussi;
if (d20roll1 == 1) {
if (d20roll2 == 1) reussi = (attackRoll1 >= attackRoll2);
else reussi = false;
} else if (d20roll2 == 1) reussi = true;
else if (d20roll1 == 20) {
if (d20roll2 == 20) reussi = (attackRoll1 >= attackRoll2);
else reussi = true;
} else reussi = (attackRoll1 >= attackRoll2);
if (reussi) {
diminueMalediction(cible, evt);
addLineToFramedDisplay(display, "<b>Attaque réussie !</b>");
} else {
diminueMalediction(attaquant, evt);
addLineToFramedDisplay(display, "<b>L'attaque échoue.</b>");
}
if (callback) callback(attaquant, cible, display, reussi);
else {
sendChat("", endFramedDisplay(display));
addEvent(evt);
}
});
}
function injonction(msg) {
var evt = {
type: 'Injonction'
};
if (!msg.content.includes(' --attaqueMentale'))
msg.content += ' --attaqueMentale';
attaqueMagique(msg, evt, 'injonction',
function(attaquant, cible, display, reussi) {
if (reussi) {
if (attributeAsBool(cible, 'resisteInjonction')) {
addLineToFramedDisplay(display, cible.token.get('name') + " a déjà résisté à une injonction aujourd'hui, c'est sans effet");
sendChat("", endFramedDisplay(display));
addEvent(evt);
return;
}
addLineToFramedDisplay(display, cible.token.get('name') + " obéit à l'injonction");
sendChat("", endFramedDisplay(display));
addEvent(evt);
} else {
setTokenAttr(cible, 'resisteInjonction', true, evt);
addLineToFramedDisplay(display, cible.token.get('name') + " n'obéit pas à l'injonction");
sendChat("", endFramedDisplay(display));
addEvent(evt);
}
});
}
function tueurFantasmagorique(msg) {
var evt = {
type: 'Tueur fantasmagorique'
};
attaqueMagique(msg, evt, 'tueurFantasmagorique',
function(attaquant, cible, display, reussi) {
if (reussi) {
if (estNonVivant(cible)) {
addLineToFramedDisplay(display, cible.token.get('name') + " n'est pas une créature vivante, il ne peut croire à sa mort");
sendChat("", endFramedDisplay(display));
addEvent(evt);
return;
}
if (attributeAsBool(cible, 'tueurFantasmagorique')) {
addLineToFramedDisplay(display, cible.token.get('name') + " a déjà été victime d'un tueur fantasmagorique aujourd'hui, c'est sans effet");
sendChat("", endFramedDisplay(display));
addEvent(evt);
return;
}
setTokenAttr(cible, 'tueurFantasmagorique', true, evt);
var s = {
carac: 'SAG',
seuil: 10 + modCarac(attaquant, 'CHARISME')
};
var niveauAttaquant = ficheAttributeAsInt(attaquant, 'NIVEAU', 1);
var niveauCible = ficheAttributeAsInt(cible, 'NIVEAU', 1);
if (niveauCible > niveauAttaquant)
s.seuil -= (niveauCible - niveauAttaquant) * 5;
else if (niveauCible < niveauAttaquant)
s.seuil += (niveauAttaquant - niveauCible);
var expliquer = function(message) {
addLineToFramedDisplay(display, message, 80);
};
var saveOpts = {
msgPour: " pour résister au tueur fantasmagorique",
attaquant: attaquant
};
save(s, cible, expliquer, saveOpts, evt,
function(reussiteSave) {
if (reussiteSave) {
addLineToFramedDisplay(display, cible.token.get('name') + " perd l'équilibre et tombe par terre");
setState(cible, 'renverse', true, evt);
} else { //save raté
addLineToFramedDisplay(display, cible.token.get('name') + " succombe à ses pires terreurs");
updateCurrentBar(cible.token, 1, 0, evt);
setState(cible, 'mort', true, evt);
}
sendChat("", endFramedDisplay(display));
addEvent(evt);
});
} else {
setTokenAttr(cible, 'tueurFantasmagorique', true, evt);
sendChat("", endFramedDisplay(display));
addEvent(evt);
}
});
}
function sommeil(msg) { //sort de sommeil
var args = msg.content.split(' ');
if (args.length < 2) {
error("La fonction !cof-sommeil a besoin du nom ou de l'id du lanceur de sort", args);
return;
}
var caster = tokenOfId(args[1], args[1]);
if (caster === undefined) {
error("Aucun personnage nommé " + args[1], args);
return;
}
var casterCharId = caster.charId;
var casterChar = getObj('character', casterCharId);
if (casterChar === undefined) {
error("Fiche de personnage manquante");
return;
}
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
sendPlayer(msg, "Pas de cible sélectionnée pour le sort de sommeil");
return;
}
var casterName = caster.token.get('name');
var casterCharName = casterChar.get('name');
var cha = modCarac(caster, 'CHARISME');
var attMagText = addOrigin(casterCharName, '[[' + computeArmeAtk(caster, '@{ATKMAG}') + ']]');
var action = "<b>Capacité</b> : Sort de sommeil";
var display = startFramedDisplay(playerId, action, caster);
sendChat("", "[[1d6]] [[" + attMagText + "]]", function(res) {
var rolls = res[0];
var afterEvaluate = rolls.content.split(" ");
var d6RollNumber = rollNumber(afterEvaluate[0]);
var attMagRollNumber = rollNumber(afterEvaluate[1]);
var nbTargets = rolls.inlinerolls[d6RollNumber].results.total + cha;
var attMag = rolls.inlinerolls[attMagRollNumber].results.total;
var evt = {
type: 'sommeil',
};
var targetsWithSave = [];
var targetsWithoutSave = [];
iterSelected(selected, function(perso) {
perso.name = perso.token.get('name');
if (estNonVivant(perso)) { //le sort de sommeil n'affecte que les créatures vivantes
addLineToFramedDisplay(display, perso.name + " n'est pas affecté par le sommeil");
return;
}
var pv = perso.token.get('bar1_max');
if (pv > 2 * attMag) {
var line =
perso.name + " a trop de PV pour être affecté par le sort";
addLineToFramedDisplay(display, line);
} else if (pv > attMag) {
targetsWithSave.push(perso);
} else {
targetsWithoutSave.push(perso);
}
});
var targets = [];
var i, r;
if (targetsWithoutSave.length > nbTargets) {
i = 0; //position to decide
while (nbTargets > 0) {
r = randomInteger(nbTargets) + i;
targets.push(targetsWithoutSave[r]);
targetsWithoutSave[r] = targetsWithoutSave[i];
i++;
nbTargets--;
}
} else {
targets = targetsWithoutSave;
nbTargets -= targets.length;
}
targets.forEach(function(t) {
setState(t, 'endormi', true, evt);
addLineToFramedDisplay(display, t.name + " s'endort");
});
if (nbTargets > 0 && targetsWithSave.length > 0) {
if (targetsWithSave.length > nbTargets) {
i = 0;
targets = [];
while (nbTargets > 0) {
r = randomInteger(nbTargets) + i;
targets.push(targetsWithSave[r]);
targetsWithSave[r] = targetsWithSave[i];
i++;
nbTargets--;
}
} else {
targets = targetsWithSave;
nbTargets -= targets.length;
}
var seuil = 10 + cha;
var tokensToProcess = targets.length;
var sendEvent = function() {
if (tokensToProcess == 1) {
addEvent(evt);
sendChat("", endFramedDisplay(display));
}
tokensToProcess--;
};
targets.forEach(function(t) {
testCaracteristique(t, 'SAG', seuil, {}, evt,
function(testRes) {
var line = "Jet de résistance de " + t.name + ":" + testRes.texte;
var sujet = onGenre(t.charId, 'il', 'elle');
if (testRes.reussite) {
line += ">=" + seuil + ", " + sujet + " ne s'endort pas";
} else {
setState(t, 'endormi', true, evt);
line += "<" + seuil + ", " + sujet + " s'endort";
}
addLineToFramedDisplay(display, line);
sendEvent();
});
});
} else { // all targets are without save
addEvent(evt);
sendChat("", endFramedDisplay(display));
}
});
}, {
lanceur: caster
});
}
//!cof-attaque-magique-contre-pv {selected|token_id} {target|token_id}
function attaqueMagiqueContrePV(msg) {
var options = parseOptions(msg);
if (options === undefined || options.cmd === undefined) return;
var cmd = options.cmd;
if (cmd.length < 3) {
error("Il faut au moins 2 arguments à !cof-attaque-magique-contre-pv", cmd);
return;
}
var attaquant = tokenOfId(cmd[1], cmd[1]);
var cible = tokenOfId(cmd[2], cmd[2]);
if (attaquant === undefined || cible === undefined) {
error("Arguments de !cof-attaque-magique-contre-pv incorrects", cmd);
return;
}
if (options.portee !== undefined) {
var distance = distanceCombat(attaquant.token, cible.token, options.pageId);
if (distance > options.portee) {
sendChar(attaquant.charId, "est trop loin de " + cible.token.get('name') +
" pour l'attaque magique");
return;
}
}
var pvMax = parseInt(cible.token.get('bar1_max'));
if (isNaN(pvMax)) {
error("Token avec des PV max qui ne sont pas un nombre", cible.token);
return;
}
var evt = {
type: 'Attaque magique',
};
if (limiteRessources(attaquant, options, 'attaque magique', "l'attaque magique", evt)) return;
var attaquantChar = getObj('character', attaquant.charId);
if (attaquantChar === undefined) {
error("Fiche de l'attaquant introuvable");
return;
}
attaquant.tokName = attaquant.token.get('name');
attaquant.name = attaquantChar.get('name');
var playerId = options.playerId || getPlayerIdFromMsg(msg);
var explications = [];
var bonusA = bonusDAttaque(attaquant, explications, evt);
if (bonusA === 0) bonusA = "";
else if (bonusA > 0) bonusA = " +" + bonusA;
var attMagText = addOrigin(attaquant.name, "[[" + computeArmeAtk(attaquant, '@{ATKMAG}') + bonusA + "]]");
var de = computeDice(attaquant);
var action = "<b>Attaque magique</b> (contre pv max)";
var display = startFramedDisplay(playerId, action, attaquant, {
perso2: cible
});
sendChat("", "[[" + de + "]] " + attMagText, function(res) {
var rolls = res[0];
var afterEvaluate = rolls.content.split(" ");
var attRollNumber = rollNumber(afterEvaluate[0]);
var attSkillNumber = rollNumber(afterEvaluate[1]);
var d20roll = rolls.inlinerolls[attRollNumber].results.total;
var attSkill = rolls.inlinerolls[attSkillNumber].results.total;
var attackRoll = d20roll + attSkill;
var line =
attaquant.tokName + " fait " +
buildinline(rolls.inlinerolls[attRollNumber]);
if (attSkill > 0) line += "+" + attSkill + " = " + attackRoll;
else if (attSkill < 0) line += attSkill + " = " + attackRoll;
addLineToFramedDisplay(display, line);
var reussi;
if (d20roll == 1) reussi = false;
else if (d20roll == 20) reussi = true;
else reussi = (attackRoll >= pvMax);
if (reussi) {
addLineToFramedDisplay(display, "<b>Attaque réussie !</b>");
} else {
diminueMalediction(attaquant, evt);
addLineToFramedDisplay(display, "<b>L'attaque échoue.</b>");
}
sendChat("", endFramedDisplay(display));
addEvent(evt);
}); //Fin du jet de dés pour l'attaque
}
function transeGuerison(msg) {
if (stateCOF.combat) {
sendPlayer(msg, "Pas possible de méditer en combat");
return;
}
var options = parseOptions(msg);
if (options === undefined) return;
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
sendPlayer(msg, "Pas de cible sélectionnée pour la transe de guérison");
return;
}
var evt = {
type: "Transe de guérison",
};
iterSelected(selected, function(perso) {
var token = perso.token;
if (attributeAsBool(perso, 'transeDeGuérison')) {
sendChar(perso.charId, "a déjà médité depuis le dernier combat");
return;
}
var bar1 = parseInt(token.get("bar1_value"));
var pvmax = parseInt(token.get("bar1_max"));
if (isNaN(bar1) || isNaN(pvmax)) return;
if (bar1 >= pvmax) {
sendChar(perso.charId, "n'a pas besoin de méditer");
return;
}
var sagMod = modCarac(perso, 'SAGESSE');
var niveau = ficheAttributeAsInt(perso, 'NIVEAU', 1);
var soin = niveau + sagMod;
if (soin < 0) soin = 0;
if (bar1 === 0) {
if (attributeAsBool(perso, 'etatExsangue')) {
removeTokenAttr(perso, 'etatExsangue', evt, "retrouve des couleurs");
}
}
bar1 += soin;
if (bar1 > pvmax) {
soin -= (bar1 - pvmax);
bar1 = pvmax;
}
updateCurrentBar(token, 1, bar1, evt);
setTokenAttr(perso, 'transeDeGuérison', true, evt);
sendChar(perso.charId, "entre en méditation pendant 10 minutes et récupère " + soin + " points de vie.");
});
addEvent(evt);
});
}
function raceIs(perso, race) {
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
return (charRace.toLowerCase() == race.toLowerCase());
}
function estMortVivant(perso) {
if (charAttributeAsBool(perso, 'mort-vivant')) return true;
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
switch (charRace.toLowerCase()) {
case 'squelette':
case 'zombie':
case 'mort-vivant':
case 'momie':
case 'goule':
case 'vampire':
return true;
default:
return false;
}
}
function estNonVivant(perso) {
return (charAttributeAsBool(perso, 'nonVivant') ||
attributeAsBool(perso, 'masqueMortuaire') || estMortVivant(perso));
}
function estUnGeant(perso) {
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
switch (charRace.trim().toLowerCase()) {
case 'géant':
case 'geant':
case 'ogre':
case 'ettin':
case 'cyclope':
return true;
default:
return false;
}
}
function estHumanoide(perso) {
if (charAttributeAsBool(perso, 'humanoide')) return true;
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
switch (charRace.trim().toLowerCase()) {
case 'humain':
case 'nain':
case 'elfe':
case 'elfe des bois':
case 'elfe noir':
case 'drow':
case 'halfelin':
case 'géant':
case 'geant':
case 'ange':
case 'barghest':
case 'démon':
case 'doppleganger':
case 'dryade':
case 'gnoll':
case 'gobelin':
case 'gobelours':
case 'hobegobelin':
case 'homme-lézard':
case 'kobold':
case 'nymphe':
case 'ogre':
case 'orque':
case 'pixie':
case 'troll':
return true;
default:
return false;
}
}
function estQuadrupede(perso) {
if (charAttributeAsBool(perso, 'quadrupede')) return true;
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
switch (charRace.trim().toLowerCase()) {
case 'ankheg':
case 'araignée':
case 'araignee':
case 'basilic':
case 'béhir':
case 'behir':
case 'bulette':
case 'bison':
case 'centaure':
case 'cheval':
case 'chien':
case 'chimère':
case 'chimere':
case 'cockatrice':
case 'crocodile':
case 'dragon':
case 'drider':
case 'eléphant':
case 'elephant':
case 'éléphant':
case 'mammouth':
case 'griffon':
case 'hipogriffe':
case 'hippogriffe':
case 'hydre':
case 'licorne':
case 'lion':
case 'loup':
case 'worg':
case 'manticore':
case 'ours':
case 'panthere':
case 'panthère':
case 'pegase':
case 'pégase':
case 'pieuvre':
case 'rat':
case 'rhinoceros':
case 'rhinocéros':
case 'sanglier':
case 'taureau':
case 'tigre':
return true;
default:
return false;
}
}
function estAnimal(perso) {
if (charAttributeAsBool(perso, 'animal')) return true;
var attr = findObjs({
_type: 'attribute',
_characterid: perso.charId,
});
var attrProfile = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'PROFIL';
});
if (attrProfile.length > 0) {
if (attrProfile[0].get('current').trim().toLowerCase() == 'animal')
return true;
}
var attrRace = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'RACE';
});
if (attrRace.length === 0) return false;
var charRace = attrRace[0].get('current').trim().toLowerCase();
switch (charRace) {
case 'animal':
case 'aigle':
case 'basilic':
case 'bulette':
case 'bison':
case 'calmar':
case 'chauve-souris':
case 'cheval':
case 'chien':
case 'crocodile':
case 'dinosaure':
case 'éléphant':
case 'eléphant':
case 'elephant':
case 'gorille':
case 'griffon':
case 'hipogriffe':
case 'hydre':
case 'lion':
case 'loup':
case 'mammouth':
case 'manticore':
case 'ours':
case 'ours-hibou':
case 'panthère':
case 'pegase':
case 'pégase':
case 'pieuvre':
case 'rhinocéros':
case 'roc':
case 'sanglier':
case 'serpent':
case 'rat':
case 'taureau':
case 'tigre':
case 'wiverne':
return true;
default:
return false;
}
}
function estMauvais(perso) {
if (charAttributeAsBool(perso, 'mauvais')) return true;
var charRace = ficheAttribute(perso, 'RACE');
if (charRace === undefined) return false;
switch (charRace.trim().toLowerCase()) {
case 'squelette':
case 'zombie':
case 'élémentaire':
case 'démon':
case 'momie':
return true;
default:
return false;
}
}
//Retourne un encodage des tailes :
// 1 : minuscule
// 2 : très petit
// 3 : petit
// 4 : moyen
// 5 : grand
// 6 : énorme
// 7 : colossal
function taillePersonnage(perso) {
var attr = findObjs({
_type: 'attribute',
_characterid: perso.charId,
});
var attrTaille = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'TAILLE';
});
if (attrTaille.length > 0) {
switch (attrTaille[0].get('current').trim().toLowerCase()) {
case "minuscule":
return 1;
case "très petit":
case "très petite":
case "tres petit":
return 2;
case "petit":
case "petite":
return 3;
case "moyen":
case "moyenne":
case "normal":
case "normale":
return 4;
case "grand":
case "grande":
return 5;
case "énorme":
case "enorme":
return 6;
case "colossal":
case "colossale":
return 7;
default: //On passe à la méthode suivante
}
}
var attrRace = attr.filter(function(a) {
return a.get('name').toUpperCase() == 'RACE';
});
if (attrRace.length > 0) {
switch (attrRace[0].get('current').trim().toLowerCase()) {
case 'lutin':
case 'fee':
return 2;
case 'halfelin':
case 'gobelin':
case 'kobold':
return 3;
case 'humain':
case 'elfe':
case 'nain':
case 'demi-elfe':
case 'demi-orque':
case 'orque':
case 'gnome':
case 'âme-forgée':
return 4;
case 'centaure':
case 'demi-ogre':
case 'ogre':
case 'minotaure':
return 5;
}
}
return undefined;
}
function estAussiGrandQue(perso1, perso2) {
var t1 = taillePersonnage(perso1);
var t2 = taillePersonnage(perso2);
if (t1 === undefined || t2 === undefined) return true;
return t1 >= t2;
}
function soigner(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd.length < 2) {
error("Il faut au moins un argument à !cof-soin", cmd);
return;
}
var soigneur = options.lanceur;
var pageId = options.pageId;
var cible;
var argSoin;
if (cmd.length > 4) {
error("Trop d'arguments à !cof-soin", cmd);
}
if (cmd.length > 2) { //cof-soin lanceur [cible] montant
if (soigneur === undefined) {
soigneur = tokenOfId(cmd[1], cmd[1]);
if (soigneur === undefined) {
error("Le premier argument n'est pas un token valide", cmd[1]);
return;
}
pageId = soigneur.token.get('pageid');
}
if (cmd.length > 3) { // on a la cible en argument
cible = tokenOfId(cmd[2], cmd[2], pageId);
if (cible === undefined) {
error("Le deuxième argument n'est pas un token valide: " + msg.content, cmd[2]);
return;
}
argSoin = cmd[3];
} else {
argSoin = cmd[2];
}
} else { //on a juste le montant des soins
argSoin = cmd[1];
}
if (soigneur === undefined && (options.mana || (options.portee !== undefined) || options.limiteParJour || options.limiteParCombat || options.dose)) {
error("Il faut préciser un soigneur pour ces options d'effet", options);
return;
}
var charId;
var niveau = 1;
var rangSoin = 0;
var soins;
if (soigneur) {
charId = soigneur.charId;
niveau = ficheAttributeAsInt(soigneur, 'NIVEAU', 1);
rangSoin = charAttributeAsInt(soigneur, 'voieDesSoins', 0);
}
var effet = "soins";
var nbDes = 1;
if (options.tempeteDeManaIntense) nbDes += options.tempeteDeManaIntense;
switch (argSoin) {
case 'leger':
effet += ' légers';
if (options.dose === undefined && options.limiteParJour === undefined)
options.limiteAttribut = {
nom: 'soinsLegers',
message: "ne peut plus lancer de sort de soins légers aujourd'hui",
limite: rangSoin
};
var bonusLeger = niveau + charAttributeAsInt(soigneur, 'voieDuGuerisseur', 0);
soins = "[[" + nbDes + (options.puissant ? "d10" : "d8") + " +" + bonusLeger + "]]";
if (options.portee === undefined) options.portee = 0;
break;
case 'modere':
effet += ' modérés';
if (options.dose === undefined && options.limiteParJour === undefined)
options.limiteAttribut = {
nom: 'soinsModeres',
message: "ne peut plus lancer de sort de soins modéréss aujourd'hui",
limite: rangSoin
};
if (options.portee === undefined) options.portee = 0;
var bonusModere = niveau + charAttributeAsInt(soigneur, 'voieDuGuerisseur', 0);
soins = "[[" + (nbDes + 1) + (options.puissant ? "d10" : "d8") + " +" + bonusModere + "]]";
break;
case 'groupe':
if (!stateCOF.combat) {
sendChar(charId, " ne peut pas lancer de soin de groupe en dehors des combats");
return;
}
effet += ' de groupe';
if (options.dose === undefined && options.limiteParJour === undefined)
options.limiteAttribut = {
nom: 'soinsDeGroupe',
message: " a déjà fait un soin de groupe durant ce combat",
limite: 1
};
if (options.puissant) soins = "[[1d10";
else soins = "[[" + nbDes + "d8";
var bonusGroupe = niveau + charAttributeAsInt(soigneur, 'voieDuGuerisseur', 0);
soins += " + " + bonusGroupe + "]]";
msg.content += " --allies --self";
if (options.mana === undefined) options.mana = 1;
break;
case 'secondSouffle':
if (!stateCOF.combat) {
sendChar(charId, " ne peut pas utiliser la capacité second souffle en dehors des combats");
return;
}
effet = "second souffle";
if (options.dose === undefined && options.limiteParJour === undefined)
options.limiteAttribut = {
nom: 'secondSouffle',
message: " a déjà repris son souffle durant ce combat",
limite: 1
};
soins = "[[1d10+" + niveau + "+" + modCarac(soigneur, 'CONSTITUTION') +
"]]";
cible = soigneur;
options.recuperation = true;
break;
default:
//TODO : augmenter les dés en cas de tempete de mana intense
if (options.tempeteDeManaIntense) {
var firstDicePart = argSoin.match(/[1-9][0-9]*d\d+/i);
if (firstDicePart && firstDicePart.length > 0) {
var fdp = firstDicePart[0];
nbDes = parseInt(fdp) + options.tempeteDeManaIntense;
argSoin =
argSoin.replace(fdp, nbDes + fdp.substring(fdp.search(/d/i)));
} else {
argSoin = '(' + argSoin + ')*' + (1 + options.tempeteDeManaIntense);
}
}
soins = "[[" + argSoin + "]]";
}
var playerId = getPlayerIdFromMsg(msg);
if (options.tempeteDeMana && soigneur) {
if (options.tempeteDeMana.cout === 0) {
//On demande de préciser les options
var optMana = {
mana: options.mana,
rang: options.rang,
portee: options.portee,
altruiste: options.altruiste,
soins: true
};
setTempeteDeMana(playerId, soigneur, msg.content, optMana);
return;
} else {
if (options.rang && options.tempeteDeMana.cout > options.rang) {
sendChar(soigneur.charId, "Attention, le coût de la tempête de mana (" + options.tempeteDeMana.cout + ") est supérieur au rang du sort");
}
}
}
sendChat('', soins, function(res) {
soins = res[0].inlinerolls[0].results.total;
var soinTxt = buildinline(res[0].inlinerolls[0], 'normal', true);
if (soins <= 0) {
sendChar(charId, "ne réussit pas à soigner (total de soins " + soinTxt + ")");
return;
}
var evt = {
type: effet
};
var ressourceLimiteCibleParJour;
if (options.limiteCibleParJour) {
ressourceLimiteCibleParJour = effet;
if (options.limiteCibleParJourRessource)
ressourceLimiteCibleParJour = options.limiteCibleParJourRessource;
ressourceLimiteCibleParJour = "limiteParJour_" + ressourceLimiteCibleParJour;
}
var limiteATester = true;
var soinImpossible = false;
var nbCibles;
var display;
var iterCibles = function(callback) {
if (cible) {
nbCibles = 1;
callback(cible);
} else {
getSelected(msg, function(selected) {
nbCibles = selected.length;
if (nbCibles > 1) {
display = startFramedDisplay(playerId, effet, soigneur);
} else if (nbCibles === 0) {
sendChar(charId, "personne à soigner");
return;
}
iterSelected(selected, callback);
}, {
lanceur: soigneur
});
}
};
var finSoin = function() {
if (nbCibles == 1) {
if (options.messages) {
options.messages.forEach(function(message) {
if (display) addLineToFramedDisplay(display, message);
else sendChar(charId, message);
});
}
if (display) sendChat("", endFramedDisplay(display));
addEvent(evt);
}
nbCibles--;
};
iterCibles(function(cible) {
if (ressourceLimiteCibleParJour) {
var utilisations =
attributeAsInt(cible, ressourceLimiteCibleParJour, options.limiteCibleParJour);
if (utilisations === 0) {
sendChar(cible.charId, "ne peut plus bénéficier de " + effet + " aujourd'hui");
finSoin();
return;
}
setTokenAttr(cible, ressourceLimiteCibleParJour, utilisations - 1, evt);
}
if (soinImpossible) {
finSoin();
return;
}
var token2 = cible.token;
var nomCible = token2.get('name');
var sujet = onGenre(cible.charId, 'il', 'elle');
var Sujet = onGenre(cible.charId, 'Il', 'Elle');
if (options.portee !== undefined) {
if (options.tempeteDeManaPortee) options.portee = options.portee * 2;
var distance = distanceCombat(soigneur.token, token2, pageId);
if (distance > options.portee) {
if (display)
addLineToFramedDisplay(display, "<b>" + nomCible + "</b> : trop loin pour le soin.");
else
sendChar(charId,
"est trop loin de " + nomCible + " pour le soigner.");
return;
}
}
if (limiteATester) {
limiteATester = false;
if (limiteRessources(soigneur, options, effet, effet, evt)) {
soinImpossible = true;
display = undefined;
finSoin();
return;
} else if (display) {
addLineToFramedDisplay(display, "Résultat des dés : " + soinTxt);
}
}
var callMax = function() {
if (display) {
addLineToFramedDisplay(display, "<b>" + nomCible + "</b> : pas besoin de soins.");
} else {
var maxMsg = "n'a pas besoin de ";
if (options.recuperation) {
maxMsg = "se reposer";
charId = soigneur.charId;
} else if (!soigneur || token2.id == soigneur.token.id) {
maxMsg += "se soigner";
charId = cible.charId;
} else {
maxMsg += "soigner " + nomCible;
}
sendChar(charId, maxMsg + ". " + Sujet + " est déjà au maximum de PV");
}
};
var printTrue = function(s) {
if (display) {
addLineToFramedDisplay(display,
"<b>" + nomCible + "</b> : + " + s + " PV");
} else {
var msgSoin;
if (!soigneur || token2.id == soigneur.token.id) {
msgSoin = 'se soigne';
charId = cible.charId;
} else {
msgSoin = 'soigne ' + nomCible;
}
msgSoin += " de ";
if (options.recuperation) msgSoin = "récupère ";
if (s < soins)
msgSoin += s + " PV. (Le résultat du jet était " + soinTxt + ")";
else msgSoin += soinTxt + " PV.";
sendChar(charId, msgSoin);
}
};
var pvSoigneur;
var callTrueFinal = printTrue;
if (msg.content.includes(' --transfer')) { //paie avec ses PV
if (soigneur === undefined) {
error("Il faut préciser qui est le soigneur pour utiliser l'option --transfer", msg.content);
soinImpossible = true;
return;
}
pvSoigneur = parseInt(soigneur.token.get("bar1_value"));
if (isNaN(pvSoigneur) || pvSoigneur <= 0) {
if (display)
addLineToFramedDisplay(display, "<b>" + nomCible + "</b> : plus assez de PV pour le soigner");
else
sendChar(charId,
"ne peut pas soigner " + nomCible + ", " + sujet + " n'a plus de PV");
soinImpossible = true;
finSoin();
return;
}
if (pvSoigneur < soins) {
soins = pvSoigneur;
}
callTrueFinal = function(s) {
updateCurrentBar(soigneur.token, 1, pvSoigneur - s, evt);
if (pvSoigneur == s) mort(soigneur, undefined, evt);
printTrue(s);
};
}
if (options.fx) {
var p1e = {
x: soigneur.token.get('left'),
y: soigneur.token.get('top'),
};
var p2e = {
x: cible.token.get('left'),
y: cible.token.get('top'),
};
spawnFxBetweenPoints(p1e, p2e, options.fx, pageId);
}
if (options.targetFx) {
spawnFx(cible.token.get('left'), cible.token.get('top'), options.targetFx, pageId);
}
soigneToken(cible, soins, evt, callTrueFinal, callMax);
finSoin();
}); //fin de iterCibles
}); //fin du sendChat du jet de dés
}
//Deprecated
function aoeSoin(msg) {
var args = msg.content.split(' ');
if (args.length < 2) {
error("Pas assez d'arguments pour !cof-aoe-soin: " + msg.content, args);
return;
}
var evt = {
type: 'soins'
};
var soigneur;
var soins;
var rollSoins;
if (args[1] == "groupe") {
if (msg.selected === undefined || msg.selected.length === 0) {
error("Il faut sélectionner un token qui lance le sort de soins de groupe", msg);
return;
}
if (msg.selected.length > 1) {
error("Plusieurs tokens sélectionnés comme lançant le sort de soins de groupe.", msg.selected);
}
var persoSoigneur = tokenOfId(msg.selected[0]._id);
if (persoSoigneur === undefined) {
error("Le token sélectionné ne représente aucun personnage", tokSoigneur);
return;
}
var tokSoigneur = persoSoigneur.token;
var charIdSoigneur = persoSoigneur.charId;
var niveau = ficheAttributeAsInt(persoSoigneur, 'NIVEAU', 1);
if (stateCOF.combat) {
var dejaSoigne = charAttributeAsBool(persoSoigneur, 'soinsDeGroupe');
if (dejaSoigne) {
sendChar(charIdSoigneur, " a déjà fait un soin de groupe durant ce combat");
return;
}
setTokenAttr(persoSoigneur, 'soinsDeGroupe', true, evt);
}
if (!depenseMana(persoSoigneur, 1, "lancer un soin de groupe", evt))
return;
if (msg.content.includes(' --puissant')) {
soins = rollDePlus(10, {
bonus: niveau
});
} else {
soins = rollDePlus(8, {
bonus: niveau
});
}
rollSoins = soins.roll;
soins = soins.val;
var nameSoigneur = tokSoigneur.get('name');
soigneur = getObj('character', charIdSoigneur);
if (soigneur === undefined) {
error("Fiche du soigneur introuvable");
}
msg.content += " --allies --self";
} else { // soin générique
soins = parseInt(args[1]);
rollSoins = soins;
if (isNaN(soins) || soins < 1) {
error(
"L'argument de !cof-aoe-soin doit être un nombre positif",
msg.content);
return;
}
}
if (soins <= 0) {
sendChat('', "Pas de soins (total de soins " + rollSoins + ")");
return;
}
var action = "Soins de groupe (" + rollSoins + ")";
getSelected(msg, function(selected, playerId) {
var display = startFramedDisplay(playerId, action, soigneur);
if (selected.length === 0) {
addLineToFramedDisplay(display, "Aucune cible sélectionnée pour le soin");
sendChat("", endFramedDisplay(display));
addEvent(evt);
return;
}
iterSelected(selected, function(perso) {
var name = perso.token.get('name');
var callMax = function() {
addLineToFramedDisplay(display, "<b>" + name + "</b> : Pas besoin de soins.");
};
var callTrue = function(soinsEffectifs) {
addLineToFramedDisplay(display,
"<b>" + name + "</b> : + " + soinsEffectifs + " PV");
};
soigneToken(perso, soins, evt, callTrue, callMax);
});
sendChat("", endFramedDisplay(display));
addEvent(evt);
});
}
function natureNourriciere(msg) {
getSelected(msg, function(selected) {
iterSelected(selected, function(lanceur) {
var charId = lanceur.charId;
var duree = rollDePlus(6);
var output =
"cherche des herbes. Après " + duree.roll + " heures, " +
onGenre(charId, "il", "elle");
var evt = {
type: "recherche d'herbes"
};
testCaracteristique(lanceur, 'SAG', 10, {}, evt,
function(testRes) {
if (testRes.reussite) {
output += " revient avec de quoi soigner les blessés.";
} else {
output += " revient bredouille.";
}
sendChar(charId, output);
addEvent(evt);
});
});
});
}
function ignorerLaDouleur(msg) {
getSelected(msg, function(selected) {
iterSelected(selected, function(chevalier) {
var charId = chevalier.charId;
var token = chevalier.token;
if (attributeAsInt(chevalier, 'ignorerLaDouleur', 0) > 0) {
sendChar(charId, "a déjà ignoré la doubleur une fois pendant ce combat");
return;
}
var lastAct = lastEvent();
if (lastAct === undefined || lastAct.type === undefined || !lastAct.type.startsWith('Attaque')) {
sendChar(charId, "s'y prend trop tard pour ignorer la douleur : la dernière action n'était pas une attaque");
return;
}
var aIgnore;
var evt = {
type: 'ignorer la douleur'
};
var PVid = token.get('bar1_link');
if (PVid === '') { //token non lié, effets seulement sur le token.
if (lastAct.affecte) {
var affecte = lastAct.affectes[token.id];
if (affecte && affecte.prev) {
var lastBar1 = affecte.prev.bar1_value;
var bar1 = parseInt(token.get('bar1_value'));
if (isNaN(lastBar1) || isNaN(bar1) || lastBar1 <= bar1) {
//On regarde la barre 2, peut-être qu'il s'agit de DM temporaires
var lastBar2 = affecte.prev.bar2_value;
var bar2 = parseInt(token.get('bar2_value'));
if (isNaN(lastBar2) || isNaN(bar2) || bar2 <= lastBar2) {
sendChar(charId, "ne peut ignorer la douleur : il semble que la dernière attaque ne lui ait pas enlevé de PV");
return;
}
updateCurrentBar(token, 2, lastBar2, evt);
setTokenAttr(chevalier, 'ignorerLaDouleur', bar2 - lastBar2, evt);
aIgnore = true;
} else {
updateCurrentBar(token, 1, lastBar1, evt);
setTokenAttr(chevalier, 'ignorerLaDouleur', lastBar1 - bar1, evt);
aIgnore = true;
}
}
}
} else { // token lié, il faut regarder l'attribut
var attrPV = lastAct.attributes.find(function(attr) {
return (attr.attribute.id == PVid);
});
if (attrPV) {
var lastPV = attrPV.current;
var newPV = attrPV.attribute.get('current');
if (isNaN(lastPV) || isNaN(newPV) || lastPV <= newPV) {
sendChar(charId, "ne peut ignorer la douleur : il semble que la dernière attaque ne lui ait pas enlevé de PV");
return;
}
updateCurrentBar(token, 1, lastPV, evt);
setTokenAttr(chevalier, 'ignorerLaDouleur', lastPV - newPV, evt);
aIgnore = true;
} else { //peut-être qu'il s'agit de DM temporaires
PVid = token.get('bar2_link');
attrPV = lastAct.attributes.find(function(attr) {
return (attr.attribute.id == PVid);
});
if (attrPV) {
var lastDmTemp = attrPV.current;
var newDmTemp = attrPV.attribute.get('current');
if (isNaN(lastDmTemp) || isNaN(newDmTemp) || newDmTemp <= lastDmTemp) {
sendChar(charId, "ne peut ignorer la douleur : il semble que la dernière attaque ne lui ait pas augmenté les DM temporaires");
return;
}
updateCurrentBar(token, 2, lastDmTemp, evt);
setTokenAttr(chevalier, 'ignorerLaDouleur', newDmTemp - lastDmTemp, evt);
aIgnore = true;
}
}
}
if (aIgnore) {
sendChar(charId, " ignore la douleur de la dernière attaque");
addEvent(evt);
} else {
sendChar(charId, "ne peut ignorer la douleur : il semble que la dernière attaque ne l'ait pas affecté");
}
});
});
}
function fortifiant(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 2) {
error("La fonction !cof-fortifiant attend en argument le rang dans la Voie des élixirs du créateur", cmd);
return;
}
var rang = parseInt(cmd[1]);
if (isNaN(rang) || rang < 1) {
error("Rang du fortifiant incorrect", cmd);
return;
}
getSelected(msg, function(selection) {
iterSelected(selection, function(beneficiaire) {
var evt = {
type: 'fortifiant',
attributes: []
};
if (limiteRessources(beneficiaire, options, 'elixir_fortifiant', "boire un fortifiant", evt)) return;
var name2 = beneficiaire.token.get('name');
var soins = rollDePlus(4, {
bonus: rang
});
sendChar(beneficiaire.charId, " boit un fortifiant");
soigneToken(beneficiaire, soins.val, evt, function(soinsEffectifs) {
var msgSoins = "et est soigné de ";
if (soinsEffectifs == soins.val) msgSoins += soins.roll + " PV";
else msgSoins += soinsEffectifs + " PV (le jet était " + soins.roll + ")";
sendChar(beneficiaire.charId, msgSoins);
});
// Finalement on met l'effet fortifie
setTokenAttr(beneficiaire, 'fortifie', rang + 1, evt);
addEvent(evt);
});
});
}
function lancerSort(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("La fonction !cof-lancer-sort attend en argument le coût en mana", cmd);
return;
}
cmd.shift();
var indexLanceur = cmd.findIndex(function(c) {
return c == '--lanceur';
});
if (indexLanceur > -1 && indexLanceur < cmd.length - 1) {
var l = tokenOfId(cmd[indexLanceur + 1]);
if (l) {
msg.selected = [{
_id: cmd[indexLanceur + 1]
}];
cmd.splice(indexLanceur, 2);
}
}
var mana = parseInt(cmd.shift());
if (isNaN(mana) || mana < 0) {
error("Le deuxième argument de !cof-lancer-sort doit être un nombre positif", msg.content);
return;
}
var spell = cmd.join(' ');
getSelected(msg, function(selected) {
if (selected.length === 0) {
error("Pas de token sélectionée pour !cof-lancer-sort", cmd);
return;
}
iterSelected(selected, function(lanceur) {
var charId = lanceur.charId;
var evt = {
type: "lancement de sort"
};
if (depenseMana(lanceur, mana, spell, evt)) {
whisperChar(charId, spell);
addEvent(evt);
}
});
});
}
function emulerAs(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("Il manque le nom du personnage pour !cof-as", msg.content);
return;
}
cmd.shift();
var nomPerso = cmd.shift();
if (nomPerso.charAt(0) == '"') {
nomPerso = nomPerso.substring(1);
var inComma = cmd.length;
while (inComma) {
nomPerso += ' ' + cmd.shift();
inComma--;
if (nomPerso.endsWith('"')) {
nomPerso = nomPerso.substr(0, nomPerso.length - 1);
inComma = 0;
}
}
}
var message = cmd.join(' ');
sendChat(nomPerso, message);
}
function murDeForce(msg) {
var cmd = msg.content.split(' ');
var sphere = true;
if (cmd.length > 1 && cmd[1] == 'mur') sphere = false;
var options = {
image: stateCOF.options.images.val.image_mur_de_force.val,
mana: 0
};
var args = msg.content.split(' --');
args.shift();
args.forEach(function(opt) {
var optCmd = opt.split(' ');
switch (optCmd[0]) {
case 'mana':
if (optCmd.length < 2) {
error("Il manque le coût en mana", cmd);
return;
}
options.mana = parseInt(optCmd[1]);
if (isNaN(options.mana) || options.mana < 0) {
error("Coût en mana incorrect", optCmd);
options.mana = 0;
}
return;
case 'puissant':
options.puissant = true;
return;
case 'image':
if (optCmd.length < 2) {
error("Il manque l'adresse de l'image", cmd);
return;
}
options.image = optCmd[1];
return;
case 'no-image':
options.image = undefined;
return;
default:
error("Option inconnue", cmd);
}
});
getSelected(msg, function(selected) {
if (selected.length === 0) {
sendPlayer(msg, "Aucun personnage sélectionné pour lancer le mur de force");
return;
}
var evt = {
type: "Mur de force"
};
initiative(selected, evt);
iterSelected(selected, function(lanceur) {
var charId = lanceur.charId;
var token = lanceur.token;
var pageId = token.get('pageid');
if (!depenseMana(lanceur, options.mana, "lancer un mur de force", evt)) {
return;
}
sendChar(charId, "lance un sort de mur de force");
if (options.image && sphere) {
var scale = computeScale(pageId);
var diametre = PIX_PER_UNIT * (6 / scale);
var imageFields = {
_pageid: pageId,
imgsrc: options.image,
represents: '',
left: token.get('left'),
top: token.get('top'),
width: diametre,
height: diametre,
layer: 'map',
name: "Mur de force",
isdrawing: true,
};
var newImage = createObj('graphic', imageFields);
toFront(newImage);
var duree = 5 + modCarac(lanceur, 'CHARISME');
setTokenAttr(lanceur, 'murDeForce', duree, evt, undefined, getInit());
setTokenAttr(lanceur, 'murDeForceId', newImage.id, evt);
} else {
sendChar(charId, '/w "' + token.get('name') + '" ' + "placer l'image du mur sur la carte");
}
});
addEvent(evt);
});
}
function tokensEnCombat() {
var cmp = Campaign();
var turnOrder = cmp.get('turnorder');
if (turnOrder === '') return []; // nothing in the turn order
turnOrder = JSON.parse(turnOrder);
if (turnOrder.length === 0) return [];
var tokens = [];
turnOrder.forEach(function(a) {
if (a.id == -1) return;
tokens.push({
_id: a.id
});
});
return tokens;
}
function aUnCapitaine(cible, evt, pageId) {
var charId = cible.charId;
var attrs = findObjs({
_type: 'attribute',
_characterid: charId,
});
var attrCapitaine = attrs.find(function(a) {
return (a.get('name') == 'capitaine');
});
if (attrCapitaine === undefined) return false;
if (pageId === undefined) {
pageId = cible.token.get('pageid');
}
var nomCapitaine = attrCapitaine.get('current');
var idCapitaine = attrCapitaine.get('max');
var capitaine = tokenOfId(idCapitaine, nomCapitaine, pageId);
var capitaineActif = attrs.find(function(a) {
return (a.get('name') == 'capitaineActif');
});
if (capitaine && isActive(capitaine)) {
if (capitaineActif) return true;
setTokenAttr({
charId: charId
}, 'capitaineActif', true, evt);
iterSelected(tokensEnCombat(), function(perso) {
if (perso.charId == charId) updateInit(perso.token, evt);
});
return true;
}
if (capitaineActif) {
removeTokenAttr({
charId: charId
}, 'capitaineActif', evt);
iterSelected(tokensEnCombat(), function(perso) {
if (perso.charId == charId) updateInit(perso.token, evt);
});
}
return false;
}
function devientCapitaine(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 2) {
error("La fonction !cof-capitaine attend en argument l'id du capitaine ou --aucun", cmd);
return;
}
var remove;
var capitaine;
var nomCapitaine;
if (cmd[1] == '--aucun') {
remove = true;
} else {
capitaine = tokenOfId(cmd[1], cmd[1]);
if (capitaine === undefined) {
error("Le premier argument de !cof-lancer-sort doit être un token", cmd[1]);
return;
}
nomCapitaine = capitaine.token.get('name');
}
var evt = {
type: 'Capitaine'
};
getSelected(msg, function(selected) {
iterSelected(selected, function(perso) {
var charId = perso.charId;
var token = perso.token;
if (remove) {
removeTokenAttr({
charId: charId
}, 'capitaine', evt);
removeTokenAttr({
charId: charId
}, 'capitaineActif', evt);
sendChat('COF', "/w GM " + token.get('name') + " n'a plus de capitaine");
} else {
if (token.id == capitaine.token.id) return;
setTokenAttr({
charId: charId
}, 'capitaine', nomCapitaine, evt,
undefined, capitaine.token.id);
sendChat('COF', "/w GM " + nomCapitaine + " est le capitaine de " + token.get('name'));
}
});
addEvent(evt);
});
}
function distribuerBaies(msg) {
if (msg.selected === undefined || msg.selected.length != 1) {
error("Pour utiliser !cof-distribuer-baies, il faut sélectionner un token", msg);
return;
}
var druide = tokenOfId(msg.selected[0]._id);
if (druide === undefined) {
error("Erreur de sélection dans !cof-distribuer-baies", msg.selected);
return;
}
var niveau = ficheAttributeAsInt(druide, 'NIVEAU', 1);
var evt = {
type: "Distribution de baies magiques"
};
var action = "Distribue des baies";
var mangerBaie = "!cof-consommer-baie " + niveau + " --limiteParJour 1 baieMagique";
getSelected(msg, function(selected, playerId) {
var display = startFramedDisplay(playerId, action, druide);
iterSelected(selected, function(perso) {
var nom = perso.token.get('name');
var baie = tokenAttribute(perso, 'dose_baie_magique');
var nbBaies = 1;
if (baie.length > 0) {
var actionAncienne = baie[0].get('max');
var indexNiveau = actionAncienne.indexOf(' ') + 1;
var ancienNiveau = parseInt(actionAncienne.substring(indexNiveau));
if (ancienNiveau > niveau) {
addLineToFramedDisplay(display, nom + " a déjà une baie plus puissante");
return;
}
if (ancienNiveau == niveau) {
nbBaies = parseInt(baie[0].get('current'));
if (isNaN(nbBaies) || nbBaies < 0) nbBaies = 0;
nbBaies++;
}
}
setTokenAttr(perso, 'dose_baie_magique', nbBaies, evt, undefined, mangerBaie);
var line = nom + " reçoit une baie";
if (perso.token.id == druide.token.id)
line = nom + " en garde une pour " + onGenre(druide.charId, "lui", "elle");
addLineToFramedDisplay(display, line);
});
addEvent(evt);
sendChat("", endFramedDisplay(display));
}, {
lanceur: druide
}); //fin du getSelected
}
function consommerBaie(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd.length < 2) {
error("Il faut un argument à !cof-consommer-baie", cmd);
return;
}
var baie = parseInt(cmd[1]);
if (isNaN(baie) || baie < 0) {
error("L'argument de !cof-consommer-baie doit être un nombre positif", cmd);
return;
}
getSelected(msg, function(selection) {
if (selection === undefined) {
sendPlayer(msg, "Pas de token sélectionné pour !cof-consommer-baie");
return;
}
var evt = {
type: "consommer une baie"
};
iterSelected(msg.selected, function(perso) {
if (limiteRessources(perso, options, 'baieMagique', "a déjà mangé une baie aujourd'hui. Pas d'effet.", evt)) return;
var soins = rollDePlus(6, {
bonus: baie
});
soigneToken(perso, soins.val, evt, function(soinsEffectifs) {
var msgSoins = "mange une baie magique. Il est rassasié et récupère ";
if (soinsEffectifs == soins.val) msgSoins += soins.roll + " points de vie";
else msgSoins += soinsEffectifs + " PV (le jet était " + soins.roll + ")";
sendChar(perso.charId, msgSoins);
},
function() {
sendChar(perso.charId, "mange une baie magique. " + onGenre(perso.charId, "Il", "Elle") + " se sent rassasié" + onGenre(perso.charId, '', 'e') + '.');
});
});
addEvent(evt);
}); //fin de getSelected
}
function replaceInline(msg) {
if (msg.inlinerolls) {
msg.content = _.chain(msg.inlinerolls)
.reduce(function(m, v, k) {
m['$[[' + k + ']]'] = v.results.total || 0;
return m;
}, {})
.reduce(function(m, v, k) {
return m.replace(k, v);
}, msg.content)
.value();
}
}
/* Quand on protège un allié, on stocke l'id et le nom du token dans un attribut 'protegerUnAllie' (champs current et max), et pour ce token, on met un
* attribut 'protegePar_nom' où nom est le nom du token protecteur, et qui contient l'id et le nom du token protecteur
* Ces attributs disparaissent à la fin des combats */
function protegerUnAllie(msg) {
var args = msg.content.split(" ");
if (args.length < 3) {
error("Pas assez d'arguments pour !cof-proteger-un-allie: " + msg.content, args);
return;
}
var protecteur = tokenOfId(args[1], args[1]);
if (protecteur === undefined) {
error("Le premier argument n'est pas un token valide", args[1]);
return;
}
var tokenProtecteur = protecteur.token;
var charIdProtecteur = protecteur.charId;
var nameProtecteur = tokenProtecteur.get('name');
var pageId = tokenProtecteur.get('pageid');
var target = tokenOfId(args[2], args[2], pageId);
if (target === undefined) {
error("Le deuxième argument n'est pas un token valide: " + msg.content, args[2]);
return;
}
var tokenTarget = target.token;
if (tokenTarget.id == tokenProtecteur.id) {
sendChar(charIdProtecteur, "ne peut pas se protéger lui-même");
return;
}
var charIdTarget = target.charId;
var nameTarget = tokenTarget.get('name');
var evt = {
type: "Protéger un allié"
};
var attrsProtecteur = tokenAttribute(protecteur, 'protegerUnAllie');
var protegePar = 'protegePar_' + nameProtecteur;
if (attrsProtecteur.length > 0) { //On protège déjà quelqu'un
var previousTarget =
tokenOfId(attrsProtecteur[0].get('current'),
attrsProtecteur[0].get('max'), pageId);
if (previousTarget) {
if (previousTarget.token.id == tokenTarget.id) {
sendChar(charIdProtecteur, "protège déjà " + nameTarget);
return;
}
removeTokenAttr(previousTarget, protegePar, evt,
"n'est plus protégé par " + nameProtecteur);
}
}
setTokenAttr(protecteur, 'protegerUnAllie',
tokenTarget.id, evt, "protège " + nameTarget, nameTarget);
setTokenAttr(target, protegePar, tokenProtecteur.id, evt, undefined, nameProtecteur);
addEvent(evt);
}
function actionDefensive(msg) {
var cmd = msg.content.split(' ');
var def = 2; //pour une défense simple
var defMsg = "préfère se défendre pendant ce tour";
if (cmd.length > 1) {
switch (cmd[1]) {
case 'totale':
def = 4;
defMsg = "se consacre entièrement à sa défense pendant ce tour";
break;
case 'simple':
def = 2;
break;
default:
error("Argument de !cof-action-defensive non reconnu", cmd);
}
}
var evt = {
type: "action défensive"
};
getSelected(msg, function(selected) {
initiative(selected, evt);
iterSelected(selected, function(perso) {
setTokenAttr(perso, 'defenseTotale', def, evt, defMsg, stateCOF.tour);
});
addEvent(evt);
});
}
function strangulation(msg) {
var args = msg.content.split(' ');
if (args.length < 3) {
error("Pas assez d'arguments pour !cof-strangulation: " + msg.content, args);
return;
}
var necromancien = tokenOfId(args[1], args[1]);
if (necromancien === undefined) {
error("Le premier argument n'est pas un token", args[1]);
return;
}
var charId1 = necromancien.charId;
var pageId = necromancien.token.get('pageid');
var target = tokenOfId(args[2], args[2], pageId);
if (target === undefined) {
error("Le deuxième argument n'est pas un token valide: " + msg.content, args[2]);
return;
}
var charId2 = target.charId;
var name2 = target.token.get('name');
if (!attributeAsBool(target, 'strangulation')) {
sendChar(charId1, "ne peut pas maintenir la strangulation. Il faut (re)lancer le sort");
return;
}
var evt = {
type: "Strangulation"
};
var dureeStrang = tokenAttribute(target, 'dureeStrangulation');
var nouvelleDuree = 1;
if (dureeStrang.length > 0) {
nouvelleDuree = parseInt(dureeStrang[0].get('current'));
if (isNaN(nouvelleDuree)) {
log("Durée de strangulation n'est pas un nombre");
log(dureeStrang);
nouvelleDuree = 1;
} else nouvelleDuree++;
}
setTokenAttr(target, 'dureeStrangulation', nouvelleDuree, evt, undefined, true);
var deStrang = 6;
if (msg.content.includes(' --puissant')) deStrang = 8;
var dmgExpr = "[[1d" + deStrang + " ";
var modInt = modCarac(necromancien, 'INTELLIGENCE');
if (modInt > 0) dmgExpr += "+" + modInt;
else if (modInt < 0) dmgExpr += modInt;
dmgExpr += "]]";
sendChat('', dmgExpr, function(res) {
var dmg = {
type: 'magique',
total: res[0].inlinerolls[0].results.total,
display: buildinline(res[0].inlinerolls[0], 'normal', true),
};
dealDamage(target, dmg, [], evt, false, {
attaquant: necromancien
}, undefined,
function(dmgDisplay, dmg) {
sendChar(charId1, "maintient sa strangulation sur " + name2 + ". Dommages : " + dmgDisplay);
addEvent(evt);
});
});
}
function ombreMortelle(msg) {
var args = msg.content.split(' ');
if (args.length < 4) {
error("Pas assez d'arguments pour " + args[0], args);
return;
}
var lanceur = tokenOfId(args[1], args[1]);
if (lanceur === undefined) {
error("Le premier argument n'est pas un token valide", args[1]);
return;
}
var pageId = lanceur.token.get('pageid');
var cible = tokenOfId(args[2], args[2], pageId);
if (cible === undefined) {
error("La cible n'est pas un token valide", args[2]);
return;
}
cible.name = cible.token.get('name');
var duree = parseInt(args[3]);
if (isNaN(duree) || duree <= 0) {
error("La durée doit être un nombre positif", args);
return;
}
var image = stateCOF.options.images.val.image_ombre.val;
var options = {};
var opts = msg.content.split(' --');
opts.shift();
opts.forEach(function(option) {
var cmd = option.split(' ');
switch (cmd[0]) {
case 'portee':
if (cmd.length < 2) {
error("Il manque l'argument de --portee", msg.content);
return;
}
options.portee = parseInt(cmd[1]);
if (isNaN(options.portee) || options.portee < 0) {
error("La portée doit être un nombre positif", cmd);
delete options.portee;
}
return;
case 'mana':
if (cmd.length < 2) {
error("Il manque l'argument de --mana", msg.content);
return;
}
options.mana = parseInt(cmd[1]);
if (isNaN(options.mana) || options.mana < 0) {
error("Le coût en mana doit être un nombre positif", cmd);
delete options.mana;
}
return;
case 'image':
if (cmd.length < 2) {
error("Il manque l'argument de --image", msg.content);
return;
}
image = cmd[1];
return;
default:
return;
}
});
if (options.portee !== undefined) {
var distance = distanceCombat(lanceur.token, cible.token, pageId);
if (distance > options.portee) {
sendChar(lanceur.charId, "est trop loind de " + cible.name +
" pour animer son ombre");
return;
}
}
var evt = {
type: "Ombre mortelle"
};
if (options.mana) {
var msgMana = "invoquer une ombre mortelle";
if (!depenseMana(lanceur, options.mana, msgMana, evt)) return;
}
copieToken(cible, image, stateCOF.options.images.val.image_ombre.val, "Ombre de " + cible.name, 'ombreMortelle', duree, pageId, evt);
sendChar(lanceur.charId,
"anime l'ombre de " + cible.name + ". Celle-ci commence à attaquer " +
cible.name + " !");
addEvent(evt);
}
function copieToken(cible, image1, image2, nom, effet, duree, pageId, evt) {
var pv = parseInt(cible.token.get('bar1_value'));
if (isNaN(pv)) {
error("Token avec des PV qui ne sont pas un nombre", cible.token);
return;
}
if (pv > 1) pv = Math.floor(pv / 2);
var pvMax = parseInt(cible.token.get('bar1_max'));
if (isNaN(pvMax)) {
error("Token avec des PV max qui ne sont pas un nombre", cible.token);
return;
}
if (pvMax > 1) pvMax = Math.floor(pvMax / 2);
var tokenFields = {
_pageid: pageId,
imgsrc: image1,
represents: cible.charId,
left: cible.token.get('left') + 60,
top: cible.token.get('top'),
width: cible.token.get('width'),
height: cible.token.get('height'),
rotation: cible.token.get('rotation'),
layer: 'objects',
name: nom,
bar1_value: pv,
bar1_max: pvMax,
bar2_value: cible.token.get('bar2_value'),
bar2_max: cible.token.get('bar2_max'),
bar3_value: cible.token.get('bar3_value'),
bar3_max: cible.token.get('bar3_max'),
showname: true,
showplayers_name: true,
showplayers_bar1: true,
};
var newToken;
if (image1) newToken = createObj('graphic', tokenFields);
if (newToken === undefined) {
tokenFields.imgsrc = cible.token.get('imgsrc').replace("max", "thumb");
newToken = createObj('graphic', tokenFields);
if (newToken === undefined) {
log(tokenFields.imgsrc);
if (image2 && image2 != image1) {
tokenFields.imgsrc = image2;
newToken = createObj('graphic', tokenFields);
}
if (newToken === undefined) {
error("L'image du token sélectionné n'a pas été uploadé, et l'image par défaut n'est pas correcte. Impossible de créer un token.", tokenFields);
return;
}
}
}
var perso = {
token: newToken,
charId: cible.charId
};
setTokenAttr(perso, effet, duree, evt, undefined, getInit());
initPerso(perso, evt);
}
function findEsc(escaliers, escName, i) {
var fullEscName = escName + labelsEscalier[i];
var sortieEscalier = escaliers.find(function(esc) {
return esc.get('name') == fullEscName;
});
if (sortieEscalier === undefined && i > 0) return findEsc(escName, i - 1);
return sortieEscalier;
}
//Attention : ne tient pas compte de la rotation !
function intersection(pos1, size1, pos2, size2) {
if (pos1 == pos2) return true;
if (pos1 < pos2) return ((pos1 + size1 / 2) >= pos2 - size2 / 2);
return ((pos2 + size2 / 2) >= pos1 - size1 / 2);
}
var labelsEscalier = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"];
function escalier(msg) {
getSelected(msg, function(selected) {
if (selected.length === 0) {
sendPlayer(msg, "Pas de sélection de token pour !cof-escalier");
log("!cof-escalier requiert de sélectionner des tokens");
return;
}
var pageId = getObj('graphic', selected[0]._id).get('pageid');
var escaliers = findObjs({
_type: 'graphic',
_pageid: pageId,
layer: 'gmlayer'
});
if (escaliers.length === 0) {
sendPlayer(msg, "Pas de token dans le layer GM");
return;
}
var versLeHaut = true;
var loop = true;
if (msg.content) {
if (msg.content.includes(' bas')) {
versLeHaut = false;
loop = false;
} else if (msg.content.includes(' haut')) {
versLeHaut = true;
loop = false;
}
}
iterSelected(selected, function(perso) {
var token = perso.token;
var posX = token.get('left');
var sizeX = token.get('width');
var posY = token.get('top');
var sizeY = token.get('height');
var sortieEscalier;
var etages;
escaliers.forEach(function(esc) {
if (sortieEscalier) return;
if (intersection(posX, sizeX, esc.get('left'), esc.get('width')) &&
intersection(posY, sizeY, esc.get('top'), esc.get('height'))) {
var escName = esc.get('name');
var l = escName.length;
if (l > 1) {
var label = escName.substr(l - 1, 1);
escName = escName.substr(0, l - 1);
var i = labelsEscalier.indexOf(label);
if (versLeHaut) {
if (i == 11) {
if (loop) escName += labelsEscalier[0];
} else escName += labelsEscalier[i + 1];
} else {
if (i === 0) {
if (loop) escName += labelsEscalier[11];
} else escName += labelsEscalier[i - 1];
}
sortieEscalier = escaliers.find(function(esc2) {
return esc2.get('name') == escName;
});
if (sortieEscalier === undefined && loop) {
if (i > 0) { //sortie par le plus petit
escName = escName.substr(0, l - 1) + 'A';
sortieEscalier = escaliers.find(function(esc2) {
return esc2.get('name') == escName;
});
} else {
sortieEscalier = findEsc(escaliers, escName.substr(0, l - 1), 10);
}
}
}
}
});
if (sortieEscalier) {
token.set('left', sortieEscalier.get('left'));
token.set('top', sortieEscalier.get('top'));
return;
}
var err = token.get('name') + " n'est pas sur un escalier";
if (!loop) {
if (versLeHaut) err += " qui monte";
else err += " qui descend";
}
sendPlayer(msg, err);
});
}); //fin getSelected
}
function defautDansLaCuirasse(msg) {
var args = msg.content.split(' ');
if (args.length < 3) {
error("Pas assez d'arguments pour !cof-defaut-dans-la-cuirasse", args);
return;
}
var tireur = tokenOfId(args[1], args[1]);
if (tireur === undefined) {
error("Le premier argument n'est pas un token valide", args[1]);
return;
}
var pageId = tireur.token.get('pageid');
var cible = tokenOfId(args[2], args[2], pageId);
if (cible === undefined) {
error("La cible n'est pas un token valide", args[2]);
return;
}
var evt = {
type: "Défaut dans la cuirasse"
};
setTokenAttr(cible, 'defautDansLaCuirasse_' + tireur.token.get('name'), 2, evt);
sendChar(tireur.charId, "passe le tour à analyser les points faibles de " + cible.token.get('name'));
addEvent(evt);
}
function postureDeCombat(msg) {
var args = msg.content.split(' ');
if (args.length < 4) {
error("Pas assez d'arguments pour !cof-posture-de-combat", args);
return;
}
var bonus = parseInt(args[1]);
var attrDebuf = args[2];
if (attrDebuf != 'DEF' && attrDebuf != 'ATT' && attrDebuf != 'DM') {
error("L'attribut à débuffer pour la posture de combat est incorrect", args);
return;
}
var attrBuf = args[3];
if (attrBuf != 'DEF' && attrBuf != 'ATT' && attrBuf != 'DM') {
error("L'attribut à augmenter pour la posture de combat est incorrect", args);
return;
}
getSelected(msg, function(selected) {
iterSelected(selected, function(guerrier) {
if (isNaN(bonus) || bonus < 1) {
sendPlayer(msg, "choisir un bonus positif (pas " + args[1] + ") pour sa posture de combat");
return;
}
var rang = charAttributeAsInt(guerrier, "voieDuSoldat", 0);
var charId = guerrier.charId;
if (rang > 0 && rang < bonus) {
sendChar(charId, "ne peut choisir qu'un bonus inférieur à " + rang + " pour sa posture de combat");
return;
}
var evt = {
type: "Posture de combat"
};
if (attrBuf == attrDebuf) {
sendChar(charId, "prend une posture de combat neutre");
removeTokenAttr(guerrier, 'postureDeCombat', evt);
addEvent(evt);
return;
}
msg = "prend une posture ";
switch (attrBuf) {
case 'DEF':
msg += "défensive";
break;
case 'ATT':
msg += "offensive";
break;
case 'DM':
msg += "puissante";
break;
default:
}
msg += " mais ";
switch (attrDebuf) {
case 'DEF':
msg += "risquée";
break;
case 'ATT':
msg += "moins précise";
break;
case 'DM':
msg += "moins puissante";
break;
default:
}
setTokenAttr(guerrier, 'postureDeCombat', bonus, evt, msg,
attrDebuf + "_" + attrBuf);
addEvent(evt);
});
});
}
function tourDeForce(msg) {
var args = msg.content.split(' ');
if (args.length < 2) {
error("Il manque un argument à !cof-tour-de-force", args);
return;
}
var seuil = parseInt(args[1]);
var action = "<b>Capacité</b> : Tour de force";
getSelected(msg, function(selected, playerId) {
iterSelected(selected, function(barbare) {
if (isNaN(seuil)) {
sendChar(barbare.charId, "le seuil de difficulté du tour de force doit être un nombre");
return;
}
var display = startFramedDisplay(playerId, action, barbare);
var evt = {
type: "Tour de force"
};
testCaracteristique(barbare, 'FOR', seuil, {
bonus: 10
}, evt,
function(testRes) {
addLineToFramedDisplay(display, " Jet de force difficulté " + seuil);
var smsg = barbare.token.get('name') + " fait " + testRes.texte;
if (testRes.reussite) {
smsg += " => réussite";
} else {
smsg += " => échec";
}
addLineToFramedDisplay(display, smsg);
var d4 = rollDePlus(4);
var r = {
total: d4.val,
type: 'normal',
display: d4.roll
};
var explications = [];
barbare.ignoreRD = true;
dealDamage(barbare, r, [], evt, false, {}, explications,
function(dmgDisplay, dmg) {
var dmgMsg = "mais cela lui coûte " + dmgDisplay + " PV";
addLineToFramedDisplay(display, dmgMsg);
finaliseDisplay(display, explications, evt);
addEvent(evt);
});
});
});
});
}
function encaisserUnCoup(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
var evtARefaire = lastEvent();
if (cmd !== undefined && cmd.length > 1) { //On relance pour un événement particulier
evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
}
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
error("Personne n'est sélectionné pour encaisser un coup", msg);
return;
}
if (evtARefaire === undefined) {
sendChat('', "Historique d'actions vide, pas d'action trouvée pour encaisser un coup");
return;
}
if (evtARefaire.type != 'Attaque' || evtARefaire.succes === false) {
sendChat('', "la dernière action n'est pas une attaque réussie, trop tard pour encaisser le coup d'une action précédente");
return;
}
var attaque = evtARefaire.action;
if (attaque.options.distance) {
sendChat('', "Impossible d'encaisser le dernier coup, ce n'était pas une attaque au contact");
return;
}
var toProceed;
var evt = {
type: "Encaisser un coup"
};
iterSelected(selected, function(chevalier) {
if (!attributeAsBool(chevalier, 'encaisserUnCoup')) {
sendChar(chevalier.charId, "n'est pas placé pour encaisser un coup");
return;
}
if (!peutController(msg, chevalier)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var cible = attaque.cibles.find(function(target) {
return (target.token.id === chevalier.token.id);
});
if (cible === undefined) {
sendChar(chevalier.charId, "n'est pas la cible de la dernière attaque");
return;
}
removeTokenAttr(chevalier, 'encaisserUnCoup', evt);
cible.extraRD =
ficheAttributeAsInt(chevalier, 'DEFARMURE', 0) *
ficheAttributeAsInt(chevalier, 'DEFARMUREON', 1) +
ficheAttributeAsInt(chevalier, 'DEFBOUCLIER', 0) *
ficheAttributeAsInt(chevalier, 'DEFBOUCLIERON', 1);
toProceed = true;
}); //fin iterSelected
if (toProceed) {
undoEvent();
var options = attaque.options;
options.rollsAttack = attaque.rollsAttack;
options.evt = evt;
options.redo = true;
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
}
}); //fin getSelected
}
// asynchrone : on fait les jets du guerrier en opposition
function absorberAuBouclier(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
var evtARefaire = lastEvent();
if (cmd !== undefined && cmd.length > 1) { //On relance pour un événement particulier
evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
}
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
error("Personne n'est sélectionné pour absorber", msg);
return;
}
if (evtARefaire === undefined) {
sendChat('', "Historique d'actions vide, pas d'action trouvée pour absorber un coup ou un sort");
return;
}
if (evtARefaire.type != 'Attaque' || evtARefaire.succes === false) {
sendChat('', "la dernière action n'est pas une attaque réussie, trop tard pour absorber l'attaque précédente");
return;
}
var attaque = evtARefaire.action;
var options = attaque.options;
options.rollsAttack = attaque.rollsAttack;
var evt = {
type: "absorber un "
};
options.evt = evt;
options.redo = true;
var attrAbsorbe = 'absorberUn';
if (options.sortilege) {
evt.type += "sort";
attrAbsorbe += "Sort";
} else {
evt.type += "coup";
attrAbsorbe += "Coup";
}
var toProceed;
var count = selected.length;
iterSelected(selected, function(guerrier) {
if (!peutController(msg, guerrier)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
if (ficheAttributeAsInt(guerrier, 'DEFBOUCLIERON', 1) != 1) {
sendChar(guerrier.charId, "ne porte pas son bouclier, il ne peut pas " + evt.type);
count--;
return;
}
if (!attributeAsBool(guerrier, attrAbsorbe)) {
sendChar(guerrier.charId, "n'est pas placé pour " + evt.type);
count--;
return;
}
var cible = attaque.cibles.find(function(target) {
return (target.token.id === guerrier.token.id);
});
if (cible === undefined) {
sendChar(guerrier.charId, "n'est pas la cible de la dernière attaque");
count--;
return;
}
removeTokenAttr(guerrier, attrAbsorbe, evt);
toProceed = true;
var attackRollExpr = "[[" + computeDice(guerrier) + "]]";
sendChat('', attackRollExpr, function(res) {
var rolls = res[0];
var attackRoll = rolls.inlinerolls[0];
var totalAbsorbe = attackRoll.results.total;
var msgAbsorber = buildinline(attackRoll);
var attBonus = ficheAttributeAsInt(guerrier, 'NIVEAU', 1);
if (options.sortilege) {
attBonus += modCarac(guerrier, 'SAGESSE');
attBonus += ficheAttributeAsInt(guerrier, 'ATKMAG_DIV', 0);
} else {
attBonus += modCarac(guerrier, 'FORCE');
attBonus += ficheAttributeAsInt(guerrier, 'ATKCAC_DIV', 0);
}
totalAbsorbe += attBonus;
if (attBonus > 0) msgAbsorber += "+" + attBonus;
else if (attBonus < 0) msgAbsorber += attBonus;
var explAbsorber = [];
var attAbsBonus = bonusAttaqueA(cible, 'bouclier', evt, explAbsorber, {});
var pageId = guerrier.token.get('pageid');
var bad = bonusAttaqueD(cible, attaque.attaquant, 0, pageId, evt, explAbsorber, {});
attAbsBonus += bad;
if (attAbsBonus > 0) msgAbsorber += "+" + attAbsBonus;
else if (attAbsBonus < 0) msgAbsorber += attAbsBonus;
explAbsorber.push(cible.tokName + " tente d'absorber l'attaque avec son bouclier. " + onGenre(cible.charId, "Il", "elle") + " fait " + msgAbsorber);
cible.absorber = totalAbsorbe;
cible.absorberDisplay = msgAbsorber;
cible.absorberExpl = explAbsorber;
count--;
if (count === 0) {
toProceed = false;
undoEvent();
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
}
}); //fin lancé de dés asynchrone
}); //fin iterSelected
if (count === 0 && toProceed) {
undoEvent();
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
}
}); //fin getSelected
}
// asynchrone : on fait les jets du barde en opposition
function esquiveAcrobatique(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
var evtARefaire = lastEvent();
if (cmd !== undefined && cmd.length > 1) { //On relance pour un événement particulier
evtARefaire = findEvent(cmd[1]);
if (evtARefaire === undefined) {
error("L'action est trop ancienne ou a été annulée", cmd);
return;
}
}
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
error("Personne n'est sélectionné pour esquiver", msg);
return;
}
if (evtARefaire === undefined) {
sendChat('', "Historique d'actions vide, pas d'action trouvée pour esquiver");
return;
}
if (evtARefaire.type != 'Attaque' || evtARefaire.succes === false) {
sendChat('', "la dernière action n'est pas une attaque réussie, trop tard pour absorber l'attaque précédente");
return;
}
var attaque = evtARefaire.action;
var options = attaque.options;
options.rollsAttack = attaque.rollsAttack;
var evt = {
type: "esquive acrobatique",
attributes: []
};
options.evt = evt;
options.redo = true;
var toProceed;
var count = selected.length;
iterSelected(selected, function(barde) {
if (!peutController(msg, barde)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
count--;
return;
}
var esquiveAcrobatique = tokenAttribute(barde, 'esquiveAcrobatique');
if (esquiveAcrobatique.length === 0) {
sendChar(barde.charId, "ne sait pas faire d'esquive acrobatique");
count--;
return;
}
esquiveAcrobatique = esquiveAcrobatique[0];
var curEsquiveAcrobatique = parseInt(esquiveAcrobatique.get('current'));
if (isNaN(curEsquiveAcrobatique)) {
error("Resource pour esquive acrobatique mal formée", esquiveAcrobatique);
count--;
return;
}
if (curEsquiveAcrobatique < 1) {
sendChar(barde.charId, " a déjà fait une esquive acrobatique ce tour");
count--;
return;
}
var cible = attaque.cibles.find(function(target) {
return (target.token.id === barde.token.id);
});
if (cible === undefined) {
sendChar(barde.charId, "n'est pas la cible de la dernière attaque");
count--;
return;
}
evt.attributes.push({
attribute: esquiveAcrobatique,
current: curEsquiveAcrobatique
});
esquiveAcrobatique.set('current', curEsquiveAcrobatique - 1);
toProceed = true;
var attackRollExpr = "[[" + computeDice(barde) + "]]";
sendChat('', attackRollExpr, function(res) {
var rolls = res[0];
var attackRoll = rolls.inlinerolls[0];
var totalEsquive = attackRoll.results.total;
var msgEsquiver = buildinline(attackRoll);
var attBonus = ficheAttributeAsInt(barde, 'NIVEAU', 1);
attBonus += modCarac(barde, 'DEXTERITE');
attBonus += ficheAttributeAsInt(barde, 'ATKTIR_DIV', 0);
totalEsquive += attBonus;
if (attBonus > 0) msgEsquiver += "+" + attBonus;
else if (attBonus < 0) msgEsquiver += attBonus;
var explEsquiver = [];
var attAbsBonus = bonusAttaqueA(cible, 'esquive acrobatique', evt, explEsquiver, {});
var pageId = barde.token.get('pageid');
var bad = bonusAttaqueD(cible, attaque.attaquant, 0, pageId, evt, explEsquiver, {});
attAbsBonus += bad;
if (attAbsBonus > 0) msgEsquiver += "+" + attAbsBonus;
else if (attAbsBonus < 0) msgEsquiver += attAbsBonus;
explEsquiver.push(cible.tokName + " tente une esquive acrobatique. " + onGenre(cible.charId, "Il", "elle") + " fait " + msgEsquiver);
cible.absorber = totalEsquive;
cible.absorberDisplay = msgEsquiver;
cible.absorberExpl = explEsquiver;
count--;
if (count === 0) {
toProceed = false;
undoEvent();
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
}
}); //fin lancé de dés asynchrone
}); //fin iterSelected
if (count === 0 && toProceed) {
undoEvent();
attack(attaque.player_id, attaque.attaquant, attaque.cibles, attaque.attack_label, options);
}
}); //fin getSelected
}
// modifie res et le retourne (au cas où il ne serait pas donné)
function listRollResults(roll, res) {
res = res || [];
switch (roll.type) {
case 'V': //top-level des rolls
if (roll.rolls === undefined) break;
roll.rolls.forEach(function(r) {
listRollResults(r, res);
});
return res;
case 'R': //jet simple
if (roll.results === undefined) break;
roll.results.forEach(function(r) {
if (r.v) res.push(r.v);
else if (r.d) res.push(r.d);
else log("Type de résultat de dé inconnu " + r);
});
return res;
case 'M':
case 'L':
return res;
case 'G':
if (roll.rolls === undefined) break;
roll.rolls.forEach(function(ra) {
ra.forEach(function(r) {
listRollResults(r, res);
});
});
return res;
default:
log("tag inconnu");
}
error("Structure de roll inconnue", roll);
return res;
}
//category est un tableau de string, le premier élément étant la catégorie
//principale, le suivant la sous-catégorie, etc
//value peut être un nombre, un tableau de nombres, ou un inline roll
function addStatistics(playerId, category, value) {
if (stateCOF.statistiques === undefined) return;
var stat = stateCOF.statistiques;
if (playerId) {
var player = getObj('player', playerId);
if (player) {
//On utilise l'id roll20 qui semble persistante
var pid = player.get('d20userid');
stat[pid] = stat[pid] || {};
stat = stat[pid];
}
}
if (category) {
category.forEach(function(cat) {
stat[cat] = stat[cat] || {};
stat = stat[cat];
});
}
if (!Array.isArray(value)) {
if (value.results) value = listRollResults(value.results);
else value = [value];
}
value.forEach(function(v) {
if (isNaN(v)) {
error("statistique sur une valeur qui n'est pas un nombre", value);
return;
}
if (typeof v != 'number') v = parseInt(v);
if (stat.total) stat.total += v;
else stat.total = v;
if (stat.nombre) stat.nombre++;
else stat.nombre = 1;
});
}
function displayStatCategory(stats, indent, categoryName, accum) {
var res = {
nombre: 0,
total: 0,
};
if (stats.nombre) { //on peut afficher des résultats
res.nombre = stats.nombre;
res.total = stats.total;
}
var nindent = indent + " ";
var nAccum = [];
for (var category in stats) {
if (category == 'total' || category == 'nombre') break;
var catRes = displayStatCategory(stats[category], nindent, category, nAccum);
res.nombre += catRes.nombre;
res.total += catRes.total;
}
var msg = "aucun jet cellecté";
if (res.nombre > 0) {
var moyenne = res.total / res.nombre;
msg = res.nombre + " jet" + ((res.nombre > 1) ? "s" : "") + ", moyenne " + moyenne;
}
if (nAccum.length > 0) msg = indent + categoryName + " (" + msg + ") :";
else msg = indent + categoryName + " : " + msg;
accum.push(msg);
nAccum.forEach(function(m) {
accum.push(m);
});
return res;
}
function displayStatistics(msg) {
var stats = stateCOF.statistiques;
var display = startFramedDisplay(getPlayerIdFromMsg(msg), "Statistiques");
if (stats === undefined) {
stats = stateCOF.statistiquesEnPause;
if (stats)
addLineToFramedDisplay(display, "Statistiques en pause");
else {
addLineToFramedDisplay(display, "Aucune statistique collectée");
sendChat("COF", endFramedDisplay(display));
return;
}
}
var tot = {
total: 0,
nombre: 0
};
var players = findObjs({
type: 'player'
});
var findPlayer = function(pid) {
return players.find(function(p) {
return (p.get('d20userid') == pid);
});
};
var addMessages = function(mv) {
mv.forEach(function(m) {
addLineToFramedDisplay(display, m);
});
};
for (var category in stats) {
//first, check if the category is a player id
var pl = findPlayer(category);
var catName = category;
if (pl) catName = pl.get('displayname');
var accum = [];
var catRes = displayStatCategory(stats[category], "", catName, accum);
addMessages(accum);
tot.total += catRes.total;
tot.nombre += catRes.nombre;
}
addLineToFramedDisplay(display, tot.nombre + " jets au total, dont la somme fait " + tot.total);
sendChat("COF", endFramedDisplay(display));
}
function destructionDesMortsVivants(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var args = options.cmd;
if (args === undefined || args.length < 2) {
error("Il faut au moins un argument à !cof-destruction-des-morts-vivants", args);
return;
}
args.shift();
var dm = args.join(' ');
dm = dm.replace(/%/g, '%');
dm = dm.replace(/\)/g, ')');
dm = dm.replace(/\?/g, '?');
dm = dm.replace(/@/g, '@');
dm = dm.replace(/\[/g, '[');
dm = dm.replace(/\]/g, ']');
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "Il faut sélectionner le lanceur de la destruction des morts-vivants");
return;
}
if (selected.length > 1) {
sendPlayer(msg, "Ne sélectionner qu'un token à la fois pour lancer la destruction des mort-vivants.");
return;
}
iterSelected(selected, function(lanceur) {
if (options.tempeteDeMana) {
if (options.tempeteDeMana.cout === 0) {
//On demande de préciser les options
var optMana = {
mana: options.mana,
dm: true,
soins: false,
duree: false,
rang: options.rang,
};
setTempeteDeMana(playerId, lanceur, msg.content, optMana);
return;
} else {
if (options.rang && options.tempeteDeMana.cout > options.rang) {
sendChar(lanceur.charId, "Attention, le coût de la tempête de mana (" + options.tempeteDeMana.cout + ") est supérieur au rang du sort");
}
}
}
if (options.tempeteDeManaIntense) {
var findNbDes = dm.match(/^([0-9]+)d/);
if (findNbDes && findNbDes.length > 1) {
var nbDes = parseInt(findNbDes[1]);
dm = dm.replace(findNbDes[0], (nbDes + options.tempeteDeManaIntense) + 'd');
} else {
log("Pas réussi à trouver le nombre de dés dans " + dm);
}
}
var evt = {
type: "Destruction des morts-vivants"
};
if (!depenseMana(lanceur, options.mana, "lancer une destruction des mort-vivants", evt)) {
addEvent(evt);
return;
}
var display = startFramedDisplay(playerId,
"<b>Sort :<b> destruction des morts-vivants", lanceur);
var name = lanceur.token.get('name');
testCaracteristique(lanceur, 'SAG', 13, {}, evt,
function(testRes) {
var msgJet = "Jet de SAG : " + testRes.texte;
if (testRes.reussite) {
var eventId = stateCOF.eventId;
var action = "!cof-dmg " + dm + " --once " + eventId + " --morts-vivants";
evt.waitingForAoe = true;
addLineToFramedDisplay(display, msgJet + " ≥ 13");
sendChat(name, endFramedDisplay(display));
sendChat('COF', "/w GM Sélectionner les token en vue de " + name + ", et [cliquer ici](" + action + ")");
} else {
addLineToFramedDisplay(display, msgJet + " < 13");
addLineToFramedDisplay(display, name + " ne réussit pas à invoquer son dieu.");
sendChat(name, endFramedDisplay(display));
}
addEvent(evt);
});
});
});
}
//!cof-enduire-poison label type dm save
//si label = munition_nom, alors on enduit des munitions et non une arme.
function enduireDePoison(msg) {
var optArgs = msg.content.split(' --');
var cmd = optArgs[0].split(' ');
optArgs.shift();
if (cmd.length < 5) {
error("Usage : !cof-enduire-poison L type force save", cmd);
return;
}
var labelArme = cmd[1];
var typePoison = cmd[2];
if (typePoison != 'rapide') {
error("Le seul type de poison géré est rapide, pas " + typePoison, cmd);
}
var attribut = 'poisonRapide_' + labelArme;
var nomMunition;
var estMunition = labelArme.startsWith('munition_');
if (estMunition) nomMunition = labelArme.substring(9);
var forcePoison = cmd[3];
var savePoison = parseInt(cmd[4]);
if (isNaN(savePoison)) {
error("Le dernier argument non optionnel doit être la difficulté du test de CON", cmd);
return;
}
var testINT = 14;
var dose;
var decrAttribute;
var proprio;
optArgs.forEach(function(arg) {
cmd = arg.split(' ');
switch (cmd[0]) {
case 'testINT':
if (cmd.length < 2) {
error("Il faut un argument à --testINT", cmd);
return;
}
testINT = parseInt(cmd[1]);
if (isNaN(testINT)) {
error("Argument de --testINT invalide", cmd);
testINT = 14;
}
return;
case 'dose':
if (cmd.length < 2) {
error("Il manque le nom de la dose de poison", cmd);
return;
}
dose = cmd[1];
return;
case 'decrAttribute':
if (cmd.length < 2) {
error("Erreur interne d'une commande générée par bouton", cmd);
return;
}
var attr = getObj('attribute', cmd[1]);
if (attr === undefined) {
log("Attribut à changer perdu");
log(cmd);
return;
}
decrAttribute = attr;
return;
}
}); //fin du traitement des options
getSelected(msg, function(selected, playerId) {
iterSelected(selected, function(perso) {
if (proprio && perso.token.id != proprio) {
sendChar(perso.charId, "ne peut pas utiliser un poison qu'il n'a pas");
return;
}
perso.tokName = perso.token.get('name');
var attr = tokenAttribute(perso, attribut);
var armeEnduite;
var infosAdditionelles = savePoison;
if (estMunition) {
armeEnduite = nomMunition.replace(/_/g, ' ');
var attrMunitions = tokenAttribute(perso, labelArme);
if (attrMunitions.length === 0) {
sendPlayer(msg, perso.tokName + "n'a pas de munition nommée " + nomMunition);
return;
}
attrMunitions = attrMunitions[0];
var munitionsCourantes = parseInt(attrMunitions.get('current'));
var maxMunitions = parseInt(attrMunitions.get('max'));
if (isNaN(munitionsCourantes) || isNaN(maxMunitions)) {
error("Attribut de munitions mal formé", attrMunitions);
return;
}
if (munitionsCourantes === 0) {
sendPlayer(msg, "Plus de munition " + nomMunition);
return;
}
var dejaEnduits = 0;
if (attr.length > 0) {
var infos = attr[0].get('max');
var indexInfos = infos.indexOf(' ');
if (indexInfos < 1) {
error("Attribut de poison rapide de munition mal formé (il faudrait la difficulté du save + le nombre de munitions empoisonnées)", infos);
return;
}
var oldSave = parseInt(infos.substring(0, indexInfos));
dejaEnduits = parseInt(infos.substring(indexInfos + 1));
if (isNaN(dejaEnduits)) dejaEnduits = 0;
if (dejaEnduits > 0 && (attr[0].get('current') != forcePoison || oldSave != savePoison)) {
sendPlayer(msg, "Il y a déjà du poison de force " + attr[0].get('current') + "et de save " + oldSave + " sur les munitions " + armeEnduite + ". Le script ne sait pas gérer différents poisons sur les mêmes munitions.");
return;
}
}
infosAdditionelles = savePoison + ' ' + (dejaEnduits + 1);
if (dejaEnduits >= maxMunitions) {
sendPlayer(msg, "Toutes les munitions " + armeEnduite + " sont déjà enduites de poison");
return;
}
} else {
var att = getAttack(labelArme, perso);
if (att === undefined) {
error(perso.tokNname + " n'a pas d'arme associée au label " + labelArme, cmd);
return;
}
armeEnduite = att.weaponName;
if (attributeAsBool(perso, attribut)) {
sendChar(perso.charId, armeEnduite + " est déjà enduit de poison.");
return;
}
}
var evt = {
type: "Enduire de poison"
};
var display = startFramedDisplay(playerId, "Essaie d'enduire " + armeEnduite + " de poison", perso);
if (dose) {
var nomDose = dose.replace(/_/g, ' ');
var doseAttr = tokenAttribute(perso, 'dose_' + dose);
if (doseAttr.length === 0) {
sendChar(perso.charId, "n'a pas de dose de " + nomDose);
return; //evt toujours vide
}
doseAttr = doseAttr[0];
var nbDoses = parseInt(doseAttr.get('current'));
if (isNaN(nbDoses) || nbDoses < 1) {
sendChar(perso.charId, "n'a plus de dose de " + nomDose);
return; //evt toujours vide
}
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: doseAttr,
current: nbDoses
});
//À partir de ce point, tout return doit ajouter evt
nbDoses--;
addLineToFramedDisplay(display, "Il restera " + nbDoses + " dose de " + nomDose + " à " + perso.tokName);
doseAttr.set('current', nbDoses);
}
if (decrAttribute) {
var oldval = parseInt(decrAttribute.get('current'));
if (isNaN(oldval) || oldval < 1) {
sendChar(perso.charId, "n'a plus de ce poison");
return;
}
evt.attributes = evt.attributes || [];
evt.attributes.push({
attribute: decrAttribute,
current: oldval,
max: decrAttribute.get('max')
});
decrAttribute.set('current', oldval - 1);
}
//Test d'INT pour savoir si l'action réussit.
testCaracteristique(perso, 'INT', testINT, {}, evt,
function(tr) {
var jet = "Jet d'INT : " + tr.texte;
if (tr.echecCritique) { //échec critique
jet += " Échec critique !";
addLineToFramedDisplay(display, jet);
addLineToFramedDisplay(display, perso.tokName + " s'empoisonne.");
sendChat('', "[[" + forcePoison + "]]", function(res) {
var rolls = res[0];
var dmgRoll = rolls.inlinerolls[0];
var r = {
total: dmgRoll.results.total,
type: 'poison',
display: buildinline(dmgRoll, 'poison')
};
var ps = {
partialSave: {
carac: 'CON',
seuil: savePoison
}
};
var explications = [];
dealDamage(perso, r, [], evt, false, ps, explications,
function(dmgDisplay, dmg) {
explications.forEach(function(e) {
addLineToFramedDisplay(display, e);
});
addLineToFramedDisplay(perso.tokName + " subit " + dmgDisplay + " DM");
addEvent(evt);
sendChat("", endFramedDisplay(display));
}); //fin de dmg dus à l'échec critique
}); //fin du jet de dmg
} else if (tr.reussite) {
jet += " ≥ " + testINT;
addLineToFramedDisplay(display, jet);
setTokenAttr(perso, attribut, forcePoison, evt, undefined, infosAdditionelles);
addLineToFramedDisplay(display, armeEnduite + " est maintenant enduit de poison");
addEvent(evt);
sendChat("", endFramedDisplay(display));
} else { //echec normal au jet d'INT
jet += " < " + testINT + " : échec";
addLineToFramedDisplay(display, jet);
addEvent(evt);
sendChat("", endFramedDisplay(display));
}
}); //fin du test de carac
}); //fin de iterSelected
}); //fin de getSelected
}
function listeConsommables(msg) {
getSelected(msg, function(selected, playerId) {
iterSelected(selected, function(perso) {
if (perso.token.get('bar1_link') === '') {
error("La liste de consommables n'est pas au point pour les tokens non liés", perso);
return;
}
var display = startFramedDisplay(playerId, 'Liste de vos consommables :', perso, {
chuchote: true
});
var attributes = findObjs({
_type: 'attribute',
_characterid: perso.charId
});
var cpt = 0;
attributes.forEach(function(attr) {
var attrName = attr.get('name').trim();
if (!(attrName.startsWith('dose_') || attrName.startsWith('consommable_') || attrName.startsWith('elixir_'))) return;
var consName = attrName.substring(attrName.indexOf('_') + 1);
consName = consName.replace(/_/g, ' ');
var quantite = parseInt(attr.get('current'));
if (isNaN(quantite) || quantite < 1) {
//addLineToFramedDisplay(display, "0 " + consName);
return;
} else cpt++;
var action = attr.get('max').trim();
var ligne = quantite + ' ';
ligne += bouton(action, consName, perso, attr);
// Pictos : https://wiki.roll20.net/CSS_Wizardry#Pictos
ligne += bouton('!cof-echange-consommables @{selected|token_id} @{target|token_id}', '<span style="font-family:Pictos">r</span>', perso, attr, 'Cliquez pour échanger');
addLineToFramedDisplay(display, ligne);
}); //fin de la boucle sur les attributs
if (cpt === 0) addLineToFramedDisplay(display, "<code>Vous n'avez aucun consommable</code>");
else addLineToFramedDisplay(display, '<em>Cliquez sur le consommable pour l\'utiliser ou sur <tt><span style="font-family:Pictos">r</span></tt> pour l\'échanger avec un autre personnage.</em>');
sendChat('', endFramedDisplay(display));
});
}); //fin du getSelected
}
// Le premier argument est le message reçu : msg => String
// Le deuxième nous indique si on effectue un échange ou pas : echange => true/false
function utiliseConsommable(msg, echange) {
var cmd = msg.content.split(' ');
if ((!echange && cmd.length < 3) || (echange && cmd.length < 5)) {
error("Erreur interne de consommables", cmd);
return;
}
//perso1 = token avec qui utilise (ou qui va échanger) le consommable
var perso1 = tokenOfId(cmd[1]);
if (perso1 === undefined) {
log("Propriétaire perdu");
sendChat('COF', "Plus possible d'utiliser cette action. Réafficher les consommables.");
return;
}
var char1 = getObj('character', perso1.charId);
if (char1 === undefined) {
error("Token sans personnage", perso1);
return;
}
perso1.name = char1.get('name');
perso1.tokName = perso1.token.get('name');
var perso2;
if (echange) {
//perso2 = token avec lequel on va faire l'échange
perso2 = tokenOfId(cmd[2]);
if (perso2 === undefined) {
log("Destinataire perdu");
sendChat('COF', "Erreur concernant le destinataire. Veuillez réessayer.");
return;
}
var char2 = getObj('character', perso2.charId);
if (char2 === undefined) {
error("Token sans personnage", perso2);
return;
}
perso2.name = char2.get('name');
perso2.tokName = perso2.token.get('name');
}
// Vérifie les droits d'utiliser le consommable
if (msg.selected && msg.selected.length == 1) {
var utilisateur = tokenOfId(msg.selected[0]._id);
if (utilisateur === undefined) {
sendChat('COF', "Le token sélectionné n'est pas valide");
return;
}
var d = distanceCombat(perso1.token, utilisateur.token);
if (d > 0) {
sendChar(utilisateur.charId, "est trop loin de " + perso1.tokName + " pour utiliser ses objets");
return;
}
perso1 = utilisateur;
} else {
//On regarde si le joueur contrôle le token
if (!peutController(msg, perso1)) {
sendPlayer(msg, "Pas les droits pour ça");
return;
}
}
//on récupère l'attribut à utiliser/échanger de perso1
var attr1;
if (echange) attr1 = getObj('attribute', cmd[4]);
else attr1 = getObj('attribute', cmd[2]);
if (attr1 === undefined) {
log("Attribut a changé/perdu");
log(cmd);
sendChat('COF', "Plus possible d'utiliser cette action. Veuillez réafficher les consommables.");
return;
}
var attrName = attr1.get('name').trim();
var effet = attr1.get('max').trim();
//Nom du consommable (pour affichage)
var consName = attrName.substring(attrName.indexOf('_') + 1);
consName = "<code>" + consName.replace(/_/g, ' ').trim() + "</code>";
// quantité actuelle pour perso1
var quantite1 = parseInt(attr1.get('current'));
if (isNaN(quantite1) || quantite1 < 1) {
attr1.set('current', 0);
sendChat('COF', '/w "' + perso1.name + '" Vous ne disposez plus de ' + consName);
return;
}
var evt = {
type: "Utilisation de consommable",
attributes: []
};
if (echange) {
//c'est un échange
evt.type = "Échange de consommable";
if (perso1.charId != perso2.charId) {
// on baisse la valeur de 1 du consommable qu'on s'apprête à échanger
attr1.set('current', quantite1 - 1);
evt.attributes.push({
attribute: attr1,
current: quantite1,
max: effet
});
// ajout du consommable dans perso2 :
var attributes = findObjs({
_type: 'attribute',
_characterid: perso2.charId
});
var found = false;
var quantite2;
// on recherche si le consommable existe chez perso2
attributes.forEach(function(attr2) {
var attrName2 = attr2.get('name').trim();
if (!found && attrName == attrName2) {
if (attr2.get('max').trim() != effet) {
error("Échange dangereux : pas le même effet pour le consommable selon le personnage \n" + effet + "\n" + attr2.get('max'), attr2);
return;
}
found = true;
// si oui, on augmente sa quantité de 1
quantite2 = parseInt(attr2.get('current'));
if (isNaN(quantite2) || quantite2 < 1) quantite2 = 0;
attr2.set('current', quantite2 + 1);
evt.attributes.push({
attribute: attr2,
current: quantite2,
max: effet
});
}
});
// si le consommable n'a pas été trouvé, on le créé avec une valeur de 1.
if (!found) {
var attr2 = createObj("attribute", {
name: attrName,
current: 1,
max: effet,
characterid: perso2.charId
});
evt.attributes.push({
attribute: attr2,
current: null,
});
}
// on envoie un petit message précisant la résultante de l'action.
sendChat('COF', "Echange entre " + perso1.tokName + " et " + perso2.tokName + " terminée.");
sendChat('COF', '/w "' + perso1.name + '" Il vous reste <strong>' + parseInt(attr1.get('current')) + "</strong> " + consName + ".");
sendChat('COF', '/w "' + perso2.name + '" Vous possédez désormais <strong>' + quantite2 + "</strong> " + consName + ".");
// le MJ est notifié :
sendChat('COF', "/w GM " + perso1.tokName + " vient de donner <strong>1</strong> " + consName + " à " + perso2.tokName + ".");
} else {
sendChat('COF', '"/w ' + perso1.name + '" Vous ne pouvez pas échanger un consommable avec vous-même ...');
}
} else {
// on utilise le consommable
attr1.set('current', quantite1 - 1);
evt.attributes.push({
attribute: attr1,
current: quantite1,
max: effet
});
var start = msg.content.indexOf(' --message ') + 10;
sendChar(perso1.charId, msg.content.substring(start));
}
addEvent(evt);
}
//asynchrone
//callback(resultat, crit):
// resultat peut être 0, 1 ou 2 : 0 = match null, 1 le perso 1 gagne, 2 le perso 2 gagne.
// crit peut être 1 si un des deux perso a fait une réussite critique et pas l'autre, -1 si un des personnage a fait un échec critique et pas l'autre, et 0 sinon
function testOppose(perso1, carac1, perso2, carac2, explications, evt, callback) {
if (carac2 === undefined) carac2 = carac1;
var nom1 = perso1.token.get('name');
var nom2 = perso2.token.get('name');
jetCaracteristique(perso1, carac1, {}, evt, function(rt1, expl1) {
jetCaracteristique(perso2, carac2, {}, evt, function(rt2, expl2) {
explications.push("Jet de " + carac1 + " de " + nom1 + " :" + rt1.texte);
expl1.forEach(explications.push);
explications.push("Jet de " + carac2 + " de " + nom2 + " :" + rt2.texte);
expl2.forEach(explications.push);
var reussite;
var crit = 0;
if (rt1.total > rt2.total) reussite = 1;
else if (rt2.total > rt1.total) reussite = 2;
else reussite = 0;
if (rt1.echecCritique) {
if (!rt2.echecCritique) {
reussite = 2;
crit = -1;
}
} else if (rt2.echecCritique) {
reussite = 1;
crit = -1;
} else if (rt1.critique) {
if (!rt2.critique) {
reussite = 1;
crit = 1;
}
} else if (rt2.critique) {
reussite = 2;
crit = 1;
}
switch (reussite) {
case 1:
diminueMalediction(perso2, evt);
break;
case 2:
diminueMalediction(perso1, evt);
break;
}
callback(reussite, crit);
}); //Fin du jet du deuxième perso
}); //Fin du jet du premier perso
}
function provocation(msg) {
var args = msg.content.split(' --');
var cmd = args[0].split(' ');
if (cmd.length < 3) {
error("La commande !cof-provocation requiert 2 arguments", cmd);
return;
}
var voleur = tokenOfId(cmd[1]);
if (voleur === undefined) {
error("Le premier argument de !cof-provocation n'est pas un token valide");
return;
}
var cible = tokenOfId(cmd[2]);
if (cible === undefined) {
error("Le deuxième argument de !cof-provocation n'est pas un token valide");
return;
}
var nomVoleur = voleur.token.get('name');
var nomCible = cible.token.get('name');
var display =
startFramedDisplay(getPlayerIdFromMsg(msg), 'Provocation', voleur, {
perso2: cible
});
var evt = {
type: 'Provocation'
};
var jets = [];
testOppose(voleur, 'CHA', cible, 'INT', jets, evt, function(res, crit) {
jets.forEach(function(l) {
addLineToFramedDisplay(display, l);
});
var reussite;
switch (res) {
case 0: //en cas d'égalité, on considère que la provocation est réussie
diminueMalediction(cible, evt);
switch (crit) {
case -1:
reussite = "Sur un malentendu, la provocation réussit...";
break;
case 0:
case 1:
reussite = "La provocation réussit tout juste.";
}
break;
case 1:
switch (crit) {
case -1:
reussite = nomCible + " marche complètement, il attaque " + nomVoleur;
break;
case 0:
reussite = "La provocation réussit.";
break;
case 1:
reussite = "La provocation est une réussite critique !";
}
break;
case 2:
switch (crit) {
case -1:
reussite = "Échec critique de la provocation !";
break;
case 0:
reussite = "La provocation échoue";
break;
case 1:
reussite = nomCible + " voit clair dans le jeu de " + nomCible + ". La provocation échoue.";
}
}
addLineToFramedDisplay(display, reussite);
addEvent(evt);
sendChat('', endFramedDisplay(display));
}); //Fin du test opposé
}
function enSelle(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("Il faut 2 arguments pour !cof-en-selle", cmd);
return;
}
var cavalier = tokenOfId(cmd[1]);
if (cavalier === undefined) {
error("Premier argument de !cof-en-selle incorrect", cmd);
return;
}
if (attributeAsBool(cavalier, 'monteSur')) {
sendChar(cavalier.charId, " est déjà en selle");
return;
}
var tokenC = cavalier.token;
var pageId = tokenC.get('pageid');
var monture = tokenOfId(cmd[2], cmd[2], pageId);
if (monture === undefined || !charAttributeAsBool(monture, 'monture')) {
sendChar(cavalier.charId, " ne peut pas monter là-dessus");
log(cmd);
return;
}
var tokenM = monture.token;
var nomMonture = tokenM.get('name');
if (attributeAsBool(monture, 'estMontePar')) {
sendChar(cavalier.charId, " ne peut monter sur " + nomMonture + " car elle a déjà un cavalier");
return;
}
if (distanceCombat(tokenC, tokenM, pageId) > 0) {
sendChar(cavalier.charId, " est trop loin de " + nomMonture);
return;
}
var evt = {
type: 'En selle'
};
setTokenAttr(cavalier, 'monteSur', tokenM.id, evt, " monte sur " + nomMonture, nomMonture);
setTokenAttr(monture, 'estMontePar', tokenC.id, evt, undefined, tokenC.get('name'));
setTokenAttr(monture, 'positionSurMonture', tokenC.get('left') - tokenM.get('left'), evt, undefined, tokenC.get('top') - tokenM.get('top'));
setTokenAttr(monture, 'directionSurMonture', tokenC.get('rotation') - tokenM.get('rotation'), evt);
addEvent(evt);
}
function listeElixirs(rang) {
var liste = [{
nom: 'fortifiant',
action: "!cof-fortifiant $rang",
rang: 1
}];
if (rang < 2) return liste;
liste.push({
nom: 'feu_grégeois',
action: "!cof-dmg $rangd6 --feu --psave DEX [[10+@{selected|INT}]] --disque @{target|token_id} 3 10 --lanceur @{selected|token_id} --targetFx burst-fire",
rang: 2
});
if (rang < 3) return liste;
liste.push({
nom: 'élixir_de_guérison',
action: "!cof-soin 3d6+$INT",
rang: 3
});
if (rang < 4) return liste;
liste.push({
nom: "potion_d_agrandissement",
action: "!cof-effet-temp agrandissement [[5+$INT]]",
rang: 4
});
liste.push({
nom: "potion_de_forme_gazeuse",
action: "!cof-effet-temp formeGazeuse [[1d4+$INT]]",
rang: 4
});
liste.push({
nom: "potion_de_protection_contre_les_éléments",
action: "!cof-effet-temp protectionContreLesElements [[5+$INT]] --valeur $rang",
rang: 4
});
liste.push({
nom: "potion_d_armure_de_mage",
action: "!cof-effet-combat armureDuMage",
rang: 4
});
liste.push({
nom: "potion_de_chute_ralentie",
action: "est léger comme une plume.",
rang: 4
});
if (rang < 5) return liste;
liste.push({
nom: "potion_d_invisibilité",
action: "!cof-set-state invisible true --message se rend invisible ([[1d6+$INT]] minutes)",
rang: 5
});
liste.push({
nom: "potion_de_vol",
action: "se met à voler",
rang: 5
});
liste.push({
nom: "potion_de_respiration_aquatique",
action: "peut respirer sous l'eau",
rang: 5
});
liste.push({
nom: "potion_de_flou",
action: "!cof-effet-temp flou [[1d4+$INT]]",
rang: 5
});
liste.push({
nom: "potion_de_hâte",
action: "!cof-effet-temp hate [[1d6+$INT]]",
rang: 5
});
return liste;
}
//!cof-creer-elixir token_id nom_token elixir
function creerElixir(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("Pas assez d'arguments pour !cof-creer-elixir", msg.content);
return;
}
var forgesort = tokenOfId(cmd[1], cmd[1], options.pageId);
if (forgesort === undefined) {
if (msg.selected && msg.selected.length == 1) {
forgesort = tokenOfId(msg.selected[0]._id);
}
if (forgesort === undefined) {
error("Impossible de savoir qui crée l'élixir", cmd);
return;
}
}
var voieDesElixirs = charAttributeAsInt(forgesort, 'voieDesElixirs', 0);
if (voieDesElixirs < 1) {
sendChar(forgesort.charId, " ne connaît pas la Voie des Élixirs");
return;
}
var elixir = listeElixirs(voieDesElixirs).find(function(i) {
return i.nom == cmd[2];
});
if (elixir === undefined) {
var altElixirs = findObjs({
_type: 'attribute',
_characterid: forgesort.charId
});
var altElixir = altElixirs.find(function(attr) {
var attrName = attr.get('name');
if (!attrName.startsWith('Elixir ')) return false;
var rang = parseInt(attrName.substring(7));
if (isNaN(rang) || rang > 3) return false;
var nomElixir = attr.get('current');
if (nomElixir != cmd[2]) return false;
elixir = {
nom: nomElixir,
action: attr.get('max'),
rang: rang
};
return true;
});
if (elixir === undefined) {
error(forgesort.token.get('name') + " est incapable de créer " + cmd[2], cmd);
return;
}
}
var evt = {
type: "Création d'élixir"
};
if (stateCOF.options.regles.val.elixirs_sorts.val) {
if (stateCOF.options.regles.val.mana_totale.val) {
switch (elixir.rang) {
case 1:
options.mana = 1;
break;
case 2:
options.mana = 3;
break;
case 3:
options.mana = 6;
break;
case 4:
options.mana = 10;
break;
case 5:
options.mana = 15;
break;
}
} else if (elixir.rang > 2) {
options.mana = elixir.rang - 2;
}
}
if (limiteRessources(forgesort, options, 'elixirsACreer', 'élixirs à créer', evt)) return;
var attrName = 'elixir_' + elixir.nom;
var message = "crée un " + elixir.nom.replace(/_/g, ' ');
var attr = tokenAttribute(forgesort, attrName);
if (attr.length === 0) {
var action = elixir.action.replace(/\$rang/g, voieDesElixirs);
action = action.replace(/\$INT/g, modCarac(forgesort, 'INTELLIGENCE'));
setTokenAttr(forgesort, attrName, 1, evt, message, action);
} else {
var nb = parseInt(attr[0].get('current'));
if (isNaN(nb) || nb < 1) nb = 0;
setTokenAttr(forgesort, attrName, nb + 1, evt, message);
}
addEvent(evt);
}
function gestionElixir(msg) {
getSelected(msg, function(selected, playerId) {
var player = getObj('player', playerId);
if (player === undefined) {
error("Impossible de trouver le joueur", playerId);
return;
}
iterSelected(selected, function(forgesort) {
var voieDesElixirs = charAttributeAsInt(forgesort, 'voieDesElixirs', 0);
if (voieDesElixirs < 1) {
sendChar(forgesort.charId, " ne connaît pas la Voie des Élixirs");
return;
}
var elixirsACreer = voieDesElixirs * 2;
var attrElixirs = tokenAttribute(forgesort, 'elixirsACreer');
if (attrElixirs.length === 0) {
attrElixirs = setTokenAttr(forgesort, 'elixirsACreer', elixirsACreer, {});
} else {
attrElixirs = attrElixirs[0];
elixirsACreer = parseInt(attrElixirs.get('current'));
if (isNaN(elixirsACreer)) elixirsACreer = 0;
}
var titre;
if (elixirsACreer < 1)
titre = "Impossible de créer un autre élixir aujourd'hui";
else titre = "Encore " + elixirsACreer + " élixirs à créer";
var display = startFramedDisplay(playerId, titre, forgesort, {
chuchote: true
});
listeElixirs(voieDesElixirs).forEach(function(elixir) {
if (elixir.rang < 4) {
//Il est possible de changer l'élixir par défaut
var altElixir = charAttribute(forgesort.charId, 'Elixir ' + elixir.rang);
if (altElixir.length > 0) {
elixir.nom = altElixir[0].get('current');
elixir.action = altElixir[0].get('max');
}
}
var nbElixirs = 0;
var attr = tokenAttribute(forgesort, 'elixir_' + elixir.nom);
if (attr.length > 0) {
attr = attr[0];
nbElixirs = parseInt(attr.get('current'));
if (isNaN(nbElixirs) || nbElixirs < 0) nbElixirs = 0;
}
var nomElixir = elixir.nom.replace(/_/g, ' ');
var options = '';
var action;
if (elixirsACreer > 0) {
action = "!cof-creer-elixir " + forgesort.token.id + ' ' + elixir.nom;
options += bouton(action, nbElixirs, forgesort, attrElixirs);
} else {
options = nbElixirs + ' ';
}
if (nbElixirs > 0) {
action = elixir.action;
action = action.replace(/\$rang/g, voieDesElixirs);
action = action.replace(/\$INT/g, modCarac(forgesort, 'INTELLIGENCE'));
options += bouton(action, nomElixir, forgesort, attr);
} else {
options += nomElixir;
}
addLineToFramedDisplay(display, options);
});
sendChat('', endFramedDisplay(display));
});
}); //Fin du getSelected
}
function rageDuBerserk(msg) {
var typeRage = 'rage';
if (msg.content.includes(' --furie')) typeRage = 'furie';
getSelected(msg, function(selection, playerId) {
if (selection.length === 0) {
sendPlayer(msg, "Pas de token sélectionné pour la rage");
return;
}
iterSelected(selection, function(perso) {
var evt = {
type: "Rage"
};
var attrRage = tokenAttribute(perso, 'rageDuBerserk');
if (attrRage.length > 0) {
attrRage = attrRage[0];
typeRage = attrRage.get('current');
var difficulte = 13;
if (typeRage == 'furie') difficulte = 16;
//Jet de sagesse difficulté 13 pou 16 pour sortir de cet état
var options = {};
var display = startFramedDisplay(playerId, "Essaie de calmer sa " + typeRage, perso);
testCaracteristique(perso, 'SAG', difficulte, options, evt,
function(tr) {
addLineToFramedDisplay(display, "<b>Résultat du jet de SAG :</b> " + tr.texte);
addEvent(evt);
if (tr.reussite) {
addLineToFramedDisplay(display, "C'est réussi, " + perso.token.get('name') + " se calme.");
removeTokenAttr(perso, 'rageDuBerserk', evt);
} else {
var msgRate = "C'est raté, " + perso.token.get('name') + " reste enragé";
//TODO : ajouter un bouton de chance
addLineToFramedDisplay(display, msgRate);
}
sendChat('', endFramedDisplay(display));
});
} else {
//Le barbare passe en rage
if (!stateCOF.combat) {
initiative(selection, evt);
}
setTokenAttr(perso, 'rageDuBerserk', typeRage, evt, "entre dans une " + typeRage + " berserk !");
}
}); //fin iterSelected
}); //fin getSelected
}
//!cof-arme-secrete @{selected|token_id} @{target|token_id}
// TODO: ajouter la possibilité d'utiliser la chance
function armeSecrete(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("Il faut deux arguments à !cof-arme-secrete", cmd);
return;
}
var barde = tokenOfId(cmd[1]);
var cible = tokenOfId(cmd[2]);
if (barde === undefined || cible === undefined) {
error("Token non valide pour l'arme secrète", cmd);
return;
}
if (attributeAsInt(barde, 'armeSecreteBardeUtilisee')) {
sendChar(barde.charId, "a déjà utilisé son arme secrète durant ce combat");
return;
}
var evt = {
type: 'Arme secrète'
};
if (!stateCOF.combat) {
initiative([{
_id: barde.token.id
}, {
_id: cible.token.id
}], evt);
}
setTokenAttr(barde, 'armeSecreteBardeUtilisee', true, evt);
var intCible = ficheAttributeAsInt(cible, 'INTELLIGENCE', 10);
testCaracteristique(barde, 'CHA', intCible, {}, evt, function(testRes) {
var display = startFramedDisplay(getPlayerIdFromMsg(msg),
"Arme secrète", barde, {
perso2: cible
});
var line = "Jet de CHA : " + testRes.texte;
if (testRes) {
line += " ≥ " + intCible;
addLineToFramedDisplay(display, line);
addLineToFramedDisplay(display, cible.token.get('name') + " est complètement déstabilisé");
setTokenAttr(cible, 'armeSecreteBarde', 1, evt, '', getInit());
} else {
line += "< " + intCible;
addLineToFramedDisplay(display, line);
addLineToFramedDisplay(display, cible.token.get('name') + " reste insensible au charme de " + barde.token.get('name'));
}
sendChat("", endFramedDisplay(display));
addEvent(evt);
}); //fin testCarac
// testRes.texte est l'affichage du jet de dé
// testRes.reussite indique si le jet est réussi
// testRes.echecCritique, testRes.critique pour le type
}
function nouveauNomDePerso(nom) {
var characters = findObjs({
_type: 'character'
});
characters = characters.map(function(c) {
return c.get('name');
});
var trouve = characters.indexOf(nom);
if (trouve < 0) return nom;
var n = 2;
while (1) {
var nomP = nom + ' ' + n;
trouve = characters.indexOf(nomP);
if (trouve < 0) return nomP;
n++;
}
}
//!cof-animer-arbre lanceur-id target-id [rang]
function animerUnArbre(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("cof-animer-arbre attend 2 arguments", msg.content);
return;
}
var druide = tokenOfId(cmd[1], cmd[1], options.pageId);
if (druide === undefined) {
error("Le premier argument de !cof-animer-arbre n'est pas un token valie", cmd);
return;
}
var tokenArbre = getObj('graphic', cmd[2]);
if (tokenArbre === undefined) {
error("Le deuxième argument de !cof-animer-arbre n'est pas un token", cmd);
return;
}
if (tokenArbre.get('represents') !== '') {
sendChar(druide.charId, "ne peut pas animer " + tokenArbre.get('name'));
return;
}
if (options.portee !== undefined) {
var dist = distanceCombat(druide.token, tokenArbre, options.pageId);
if (dist > options.portee) {
sendChar(druide.charId, " est trop loin de l'arbre");
return;
}
}
var rang = charAttributeAsInt(druide, 'voieDesVegetaux', 3);
if (cmd.length > 3) { //Le rang est spécifié en argument optionnel
var cmd3 = parseInt(cmd[3]);
if (isNaN(cmd3) || cmd3 < 1) {
error("Le rang n'est pas un nombre valie. On utilise " + rang + " à la place", cmd);
} else rang = cmd3;
}
var evt = {
type: "Animation d'un arbre"
};
if (limiteRessources(druide, options, 'animerUnArbre', 'animer un arbre', evt)) return;
if (!stateCOF.combat) {
initPerso(druide, evt);
}
var nomArbre = nouveauNomDePerso('Arbre animé');
var charArbre = createObj('character', {
name: nomArbre,
avatar: "https://s3.amazonaws.com/files.d20.io/images/42323556/6qxlm965aFhBXGoYFy5fqg/thumb.png?1510582137"
});
evt.characters = [charArbre];
var caid = charArbre.id;
var pvArbre = rang * 10;
setToken(tokenArbre, 'represents', caid, evt);
//Les attributs n'ont pas besoin d'être ajoutés à evt, on les enlève en supprimant le personnage
createObj('attribute', {
characterid: caid,
name: 'DEXTERITE',
current: 7
});
createObj('attribute', {
characterid: caid,
name: 'DEFDIV',
current: 5
});
var pvAttr;
if (persoEstPNJ(druide)) {
pvAttr = createObj('attribute', {
characterid: caid,
name: 'pnj_pv',
current: pvArbre,
max: pvArbre
});
} else {
pvAttr = createObj('attribute', {
characterid: caid,
name: 'PV',
current: pvArbre,
max: pvArbre
});
}
createObj('attribute', {
characterid: caid,
name: 'RD_sauf_feu_tranchant',
current: 10
});
var niveau = ficheAttributeAsInt(druide, 'NIVEAU', 1);
createObj('ability', {
characterid: caid,
name: 'Attaque',
istokenaction: true,
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Branches",[' + niveau + ',0],20,[1,6,3,0],0]'
});
setToken(tokenArbre, 'bar1_link', pvAttr.id, evt);
setToken(tokenArbre, 'bar1_value', pvArbre, evt);
setToken(tokenArbre, 'bar1_max', pvArbre, evt);
setToken(tokenArbre, 'sjowplayers_bar1', true, evt);
setToken(tokenArbre, 'name', nomArbre, evt);
setToken(tokenArbre, 'showname', true, evt);
setToken(tokenArbre, 'showplayers_name', true, evt);
createObj('attribute', {
characterid: caid,
name: 'arbreAnime',
current: niveau,
max: getInit()
});
sendChar(caid, "commence à s'animer");
initiative([{
_id: tokenArbre.id
}], evt);
addEvent(evt);
}
function runeProtection(msg) {
if (!stateCOF.combat) {
sendPlayer(msg, "On ne peut utiliser les runes de protection qu'en combat");
return;
}
getSelected(msg, function(selected) {
iterSelected(selected, function(perso) {
var evt = {
type: "Rune de protection",
attributes: []
};
var attr = tokenAttribute(perso, 'runeDeProtection');
if (attr.length === 0) {
sendChar(perso.charId, "n'a pas de rune de protection");
return;
}
attr = attr[0];
var dispo = attr.get('current');
if (dispo) {
var lastAct = lastEvent();
if (lastAct === undefined) {
sendChar(perso.charId, "pas de dernière action sur laquelle utiliser la rune de protection");
return;
}
if (lastAct.affectes === undefined || lastAct.type === undefined || !lastAct.types.startsWith('Attaque')) {
sendChar(perso.charId, "la dernière action n'est pas une attaque, on ne peut utiliser la rune de protection");
return;
}
var aff = lastAct.affectes[perso.token.id];
var currentPV = perso.token.get('bar1_value');
if (aff === undefined || aff.prev === undefined ||
aff.prev.bar1_value === undefined ||
aff.prev.bar1_value <= currentPV) {
sendChar(perso.charId, "la dernière action n'a pas diminué les PV de " + perso.token.get('name'));
return;
}
sendChar(perso.charId, "utilise sa rune de protection pour ignorer les derniers dommages");
evt.attributes.push({
attribute: attr,
current: dispo
});
attr.set('current', 0);
setToken(perso.token, 'bar1_value', aff.prev.bar1_value, evt);
if (getState(perso, 'mort')) setState(perso, 'mort', false, evt);
return;
}
sendChar(perso.charId, "a déjà utilisé sa rune de protection durant ce combat");
});
});
}
//!cof-delivrance @{selected|token_id} @{target|token_id}
function delivrance(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("cof-delivrance attend 2 arguments", msg.content);
return;
}
var pretre = tokenOfId(cmd[1], cmd[1], options.pageId);
if (pretre === undefined) {
error("Le premier argument de !cof-delivrance n'est pas un token valide", msg.content);
return;
}
var cible = tokenOfId(cmd[2], cmd[2], options.pageId);
if (cible === undefined) {
error("Le deuxième argument de !cof-delivrance n'est pas un token valide", msg.content);
return;
}
cible.tokName = cible.token.get('name');
if (options.portee !== undefined) {
var dist = distanceCombat(pretre.token, cible.token, options.pageId);
if (dist > options.portee) {
sendChar(pretre.charId, " est trop loin de " + cible.tokName);
return;
}
}
var evt = {
type: "Délivrance",
deletedAttributes: []
};
if (limiteRessources(pretre, options, 'délivrance', 'délivrance', evt)) return;
var attr;
var display = startFramedDisplay(getPlayerIdFromMsg(msg), 'Délivrance', pretre, {
perso2: cible
});
var printEffet = function(message) {
addLineToFramedDisplay(display, "La cible " + message);
};
var optFin = {
print: printEffet,
pageId: options.pageId
};
_.each(messageEffetTemp, function(effet, nomEffet) {
if (effet.prejudiciable) {
//Attention, ne fonctionne pas avec les effets génériques
attr = tokenAttribute(cible, nomEffet);
if (attr.length > 0)
finDEffet(attr[0], nomEffet, attr[0].get('name'), cible.charId, evt, optFin);
}
});
_.each(messageEffetCombat, function(effet, nomEffet) {
if (effet.prejudiciable) {
attr = tokenAttribute(cible, nomEffet);
if (attr.length > 0) {
printEffet(effet.fin);
evt.deletedAttributes.push(attr[0]);
attr[0].remove();
}
}
});
if (attributeAsBool(cible, 'malediction')) {
printEffet("n'est plus maudite");
removeTokenAttr(cible, 'malediction', evt);
}
//On enlève enfin les états préjudiciables
if (getState(cible, 'aveugle')) {
printEffet("retrouve la vue");
setState(cible, 'aveugle', false, evt);
}
if (getState(cible, 'affaibli')) {
printEffet("retrouve des forces");
setState(cible, 'affaibli', false, evt);
}
if (getState(cible, 'etourdi')) {
printEffet("retrouve ses esprits");
setState(cible, 'etourdi', false, evt);
}
if (getState(cible, 'paralyse')) {
printEffet("peut à nouveau bouger");
setState(cible, 'paralyse', false, evt);
}
if (getState(cible, 'ralenti')) {
printEffet("retrouve une vitesse normale");
setState(cible, 'ralenti', false, evt);
}
if (getState(cible, 'endormi')) {
printEffet("se réveille");
setState(cible, 'endormi', false, evt);
}
if (getState(cible, 'apeure')) {
printEffet("reprend courage");
setState(cible, 'apeure', false, evt);
}
sendChat('', endFramedDisplay(display));
addEvent(evt);
}
function armeDeContact(perso, arme, labelArmeDefaut, armeContact) {
if (arme) return arme;
var labelArme = tokenAttribute(perso, 'armeEnMain');
if (labelArme.length > 0) {
labelArme = labelArme[0].get('current');
arme = getWeaponStats(perso, labelArme);
}
if (arme === undefined && labelArmeDefaut)
arme = getWeaponStats(perso, labelArmeDefaut);
//L'arme doit être une arme de contact ?
if (armeContact && arme && arme.portee) {
sendChar(perso.charId, armeContact + " " + arme.name + " est une arme à distance.");
return;
}
if (arme) {
return arme;
}
arme = {
name: 'Attaque par défaut',
attSkillDiv: 0,
attSkill: "@{ATKCAC}",
crit: 20,
parDefaut: true,
};
return arme;
}
function attaqueContactOpposee(playerId, attaquant, defenseur, evt, options, callback) {
var explications = [];
options = options || {};
options.contact = true;
attaquant.tokName = attaquant.tokName || attaquant.token.get('name');
defenseur.tokName = defenseur.tokName || defenseur.token.get('name');
if (attaquant.name === undefined) {
var charAttaquant = getObj('character', attaquant.charId);
if (charAttaquant === undefined) {
error("Attaquant sans personnage", attaquant);
return;
}
attaquant.name = charAttaquant.get('name');
}
if (defenseur.name === undefined) {
var charDefenseur = getObj('character', defenseur.charId);
if (charDefenseur === undefined) {
error("Défenseur sans personnage", defenseur);
return;
}
defenseur.name = charDefenseur.get('name');
}
entrerEnCombat(attaquant, [defenseur], explications, evt);
//Recherche des armes utilisées
var armeAttaquant = armeDeContact(attaquant, options.armeAttaquant, options.labelArmeAttaquant, options.armeAttaquantContact);
var armeDefenseur = armeDeContact(defenseur, options.armeDefenseur, options.labelArmeDefenseur, options.armeDefenseurContact);
var action = options.action || "<b>Attaque opposée</b>";
if (!armeAttaquant.parDefaut) {
action += " <span style='" + BS_LABEL + " " + BS_LABEL_INFO + "; text-transform: none; font-size: 100%;'>(" + armeAttaquant.name + ")</span>";
}
var display = startFramedDisplay(playerId, action, attaquant, {
perso2: defenseur
});
var critAttaquant = critEnAttaque(attaquant, armeAttaquant, options);
var dice = 20;
if (estAffaibli(attaquant)) {
dice = 12;
explications.push("Attaquant affaibli => D12 au lieu de D20 en Attaque");
} else if (getState(attaquant, 'immobilise')) {
dice = 12;
explications.push("Attaquant immobilisé => D12 au lieu de D20 en Attaque");
}
var toEvaluateAttack = attackExpression(attaquant, 1, dice, critAttaquant, armeAttaquant);
sendChat('', toEvaluateAttack, function(resAttack) {
var rollsAttack = options.rollsAttack || resAttack[0];
var afterEvaluateAttack = rollsAttack.content.split(' ');
var attRollNumber = rollNumber(afterEvaluateAttack[0]);
var attSkillNumber = rollNumber(afterEvaluateAttack[1]);
var d20rollAttaquant = rollsAttack.inlinerolls[attRollNumber].results.total;
var attSkill = rollsAttack.inlinerolls[attSkillNumber].results.total;
var attBonus =
bonusAttaqueA(attaquant, armeAttaquant.name, evt, explications, options);
var pageId = options.pageId || attaquant.token.get('pageid');
attBonus +=
bonusAttaqueD(attaquant, defenseur, 0, pageId, evt, explications, options);
var attackRollAttaquant = d20rollAttaquant + attSkill + attBonus;
var attRollValue = buildinline(rollsAttack.inlinerolls[attRollNumber]);
attRollValue += (attSkill > 0) ? "+" + attSkill : (attSkill < 0) ? attSkill : "";
attRollValue += (attBonus > 0) ? "+" + attBonus : (attBonus < 0) ? attBonus : "";
if (options.bonusAttaqueAttaquant) {
options.bonusAttaqueAttaquant.forEach(function(bad) {
attRollValue += (bad.val > 0) ? "+" + bad.val : (bad.val < 0) ? bad.val : "";
attackRollAttaquant += bad.val;
if (bad.explication) explications.push(bad.explication);
});
}
addLineToFramedDisplay(display, "Jet de " + attaquant.tokName + " : " + attRollValue);
var critDefenseur = critEnAttaque(defenseur, armeDefenseur, options);
var dice = 20;
if (estAffaibli(defenseur)) {
dice = 12;
explications.push("Défenseur affaibli => D12 au lieu de D20 en Attaque");
} else if (getState(defenseur, 'immobilise')) {
dice = 12;
explications.push("Défenseur immobilisé => D12 au lieu de D20 en Attaque");
}
toEvaluateAttack = attackExpression(defenseur, 1, dice, critDefenseur, armeDefenseur);
sendChat('', toEvaluateAttack, function(resAttack) {
rollsAttack = options.rollsAttack || resAttack[0];
afterEvaluateAttack = rollsAttack.content.split(' ');
attRollNumber = rollNumber(afterEvaluateAttack[0]);
attSkillNumber = rollNumber(afterEvaluateAttack[1]);
var d20rollDefenseur = rollsAttack.inlinerolls[attRollNumber].results.total;
var attSkill = rollsAttack.inlinerolls[attSkillNumber].results.total;
attBonus =
bonusAttaqueA(defenseur, armeDefenseur.name, evt, explications, options);
attBonus +=
bonusAttaqueD(defenseur, attaquant, 0, pageId, evt, explications, options);
var attackRollDefenseur = d20rollDefenseur + attSkill + attBonus;
attRollValue = buildinline(rollsAttack.inlinerolls[attRollNumber]);
attRollValue += (attSkill > 0) ? "+" + attSkill : (attSkill < 0) ? attSkill : "";
attRollValue += (attBonus > 0) ? "+" + attBonus : (attBonus < 0) ? attBonus : "";
if (options.bonusAttaqueDefenseur) {
options.bonusAttaqueDefenseur.forEach(function(bad) {
attRollValue += (bad.val > 0) ? "+" + bad.val : (bad.val < 0) ? bad.val : "";
attackRollDefenseur += bad.val;
if (bad.explication) explications.push(bad.explication);
});
}
addLineToFramedDisplay(display, "Jet de " + defenseur.tokName + " : " + attRollValue);
var resultat = {
rollAttaquant: attackRollAttaquant,
rollDefenseur: attackRollDefenseur,
};
if (d20rollAttaquant == 1 && d20rollDefenseur > 1) {
resultat.echec = true;
resultat.echecCritique = true;
diminueMalediction(attaquant, evt);
} else if (d20rollDefenseur == 1 && d20rollAttaquant > 1) {
resultat.succes = true;
resultat.echecCritiqueDefenseur = true;
diminueMalediction(defenseur, evt);
} else if (d20rollAttaquant >= critAttaquant && d20rollDefenseur < critDefenseur) {
resultat.succes = true;
resultat.critique = true;
diminueMalediction(defenseur, evt);
} else if (d20rollAttaquant < critAttaquant && d20rollDefenseur >= critDefenseur) {
resultat.succes = false;
resultat.critiqueDefenseur = true;
diminueMalediction(attaquant, evt);
} else if (attackRollAttaquant < attackRollDefenseur) {
resultat.echec = true;
diminueMalediction(attaquant, evt);
} else {
resultat.succes = true;
diminueMalediction(defenseur, evt);
}
callback(resultat, display, explications); //evt est mis à jour
}); //fin du sendchat pour jet du défenseur
}); //Fin du sendChat pour jet de l'attaquant
}
function testAttaqueOpposee(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("Il faut 2 personnages pour un test d'attaque en opposition", cmd);
return;
}
var attaquant = tokenOfId(cmd[1], cmd[1]);
var defenseur = tokenOfId(cmd[2], cmd[2]);
if (attaquant === undefined) {
error("Le premier argument de !cof-test-attaque-opposee doit être un token valide", cmd[1]);
return;
}
if (defenseur === undefined) {
error("Le deuxième argument de !cof-test-attaque-opposee doit être un token valide", cmd[2]);
return;
}
var evt = {
type: "Test d'attaque opposée"
};
var options = {};
if (cmd.length > 3) options.labelArmeAttaquant = cmd[3];
var playerId = getPlayerIdFromMsg(msg);
attaqueContactOpposee(playerId, attaquant, defenseur, evt, options,
function(res, display, explications) {
if (res.succes)
addLineToFramedDisplay(display, attaquant.token.get('name') + " remporte le test");
else
addLineToFramedDisplay(display, defenseur.token.get('name') + " remporte le test");
explications.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
sendChat("", endFramedDisplay(display));
addEvent(evt);
});
}
//!cof-desarmer attaquant cible, optionellement un label d'arme
function desarmer(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("Il manque des arguments à !cof-desarmer", msg.content);
return;
}
var guerrier = tokenOfId(cmd[1], cmd[1]);
if (guerrier === undefined) {
error("Le premier argument de !cof-desarmer n'est pas un token valide", cmd);
return;
}
guerrier.tokName = guerrier.token.get('name');
var cible = tokenOfId(cmd[2], cmd[2]);
if (cible === undefined) {
error("Le deuxième argument de !cof-desarmer n'est pas un token valide", cmd);
return;
}
cible.tokName = cible.token.get('name');
var pageId = guerrier.token.get('pageid');
if (distanceCombat(guerrier.token, cible.token, pageId)) {
sendChar(guerrier.charId, "est trop loin de " + cible.tokName + " pour le désarmer.");
return;
}
var options = {
action: "<b>Désarmement</b>",
armeContact: "doit porter une arme de contact pour désarmer son adversaire.",
armeDefenseur: armeCible,
pageId: pageId,
};
//On cherche l'arme de la cible. On en aura besoin pour désarmer
var armeCible;
var attrArmeCible = tokenAttribute(cible, 'armeEnMain');
if (attrArmeCible.length > 0) {
attrArmeCible = attrArmeCible[0];
armeCible = getWeaponStats(cible, attrArmeCible.get('current'));
if (armeCible) {
options.armeDefenseur = armeCible;
if (armeCible.deuxMains) {
options.bonusAttaqueDefenseur = [{
val: 5,
explication: cible.tokName + " porte une arme à 2 mains => +5 à son jet"
}];
}
}
} else attrArmeCible = undefined;
var enleverArmeCible = function() {
if (attrArmeCible) {
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attrArmeCible);
attrArmeCible.remove();
}
};
var evt = {
type: 'Désarmer'
};
if (cmd.length > 3) options.labelArmeAttaquant = cmd[3];
var playerId = getPlayerIdFromMsg(msg);
attaqueContactOpposee(playerId, guerrier, cible, evt, options,
function(res, display, explications) {
var resultat;
if (res.echecCritique) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_DANGER + "'><b>échec critique</b></span>";
} else if (res.echecCritiqueDefenseur) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>succès</b></span>, " + cible.tokName + " laisse tomber son arme, difficile de la récupérer...";
enleverArmeCible();
} else if (res.critique) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>réussite critique</b></span> : " + cible.tokName + " est désarmé, et " + guerrier.tokName + " empêche de reprendre l'arme";
enleverArmeCible();
} else if (res.critiqueDefenseur) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_WARNING + "'><b>échec</b></span>, " + cible.tokName + " garde son arme bien en main";
} else if (res.echec) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_WARNING + "'><b>échec</b></span>, " + guerrier.tokName + " n'a pas réussi à désarmer son adversaire";
} else { //succès
enleverArmeCible();
if (res.rollAttaquant > res.rollDefenseur + 9) {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>succès</b></span>, " + guerrier.tokName + " désarme son adversaire et l'empêche de récupérer son arme";
} else {
resultat = "<span style='" + BS_LABEL + " " + BS_LABEL_SUCCESS + "'><b>succès</b></span>, " + guerrier.tokName + " désarme son adversaire.";
}
}
addLineToFramedDisplay(display, resultat);
explications.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
sendChat("", endFramedDisplay(display));
addEvent(evt);
});
}
function appliquerBloquer(attaquant, cible, critique, evt, envoyerMessage) {
var msg;
if (envoyerMessage) msg = "est bloqué par son adversaire";
setTokenAttr(cible, 'bloqueManoeuvre', 1, evt, msg, getInit());
if (critique)
appliquerTenirADistance(attaquant, cible, false, evt, envoyerMessage);
}
function appliquerTenirADistance(attaquant, cible, critique, evt, envoyerMessage) {
var msg;
if (envoyerMessage) msg = "est tenu à distance par son adversaire";
setTokenAttr(
cible, 'tenuADistanceManoeuvre(' + attaquant.token.id + ')', 1, evt, msg, getInit());
if (critique) appliquerBloquer(attaquant, cible, false, evt, envoyerMessage);
}
var listeManoeuvres = {
aveugler: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
var duree = 1;
if (critique) duree = randomInteger(6);
var msg;
if (envoyerMessage) msg = "est aveuglé par son adversaire";
setTokenAttr(
cible, 'aveugleManoeuvre', duree, evt, msg, getInit());
return critique; //Pour les DMs en plus
},
verbe: 'aveugler'
},
bloquer: {
appliquer: appliquerBloquer,
penalitePlusPetit: true,
verbe: 'bloquer'
},
desarmer: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
var armeCible;
var attrArmeCible = tokenAttribute(cible, 'armeEnMain');
if (attrArmeCible.length > 0) {
attrArmeCible = attrArmeCible[0];
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attrArmeCible);
attrArmeCible.remove();
}
if (envoyerMessage) {
var msgDesarme = "est désarmé" + onGenre(cible.charId, '', 'e');
if (critique) msgDesarme += ", son adversaire lui a pris son arme.";
else msgDesarme += ".";
sendChar(cible.charId, msgDesarme);
}
},
verbe: 'désarmer'
},
faireDiversion: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
var msg;
if (envoyerMessage) msg = "a son attention attirée ailleurs";
var malus = -5;
if (critique) malus = -10;
setTokenAttr(cible, 'diversionManoeuvre', 1, evt, msg, getInit());
setTokenAttr(cible, 'diversionManoeuvreValeur', malus, evt, undefined);
},
verbe: 'faire diversion sur'
},
menacer: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
var msg;
if (envoyerMessage) msg = "est sous le coup d'une menace";
var effet = 'menaceManoeuvre(' + attaquant.token.id;
if (critique) effet += ',crit';
effet += ')';
setTokenAttr(cible, effet, 1, evt, msg, getInit());
},
verbe: 'menacer'
},
renverser: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
if (envoyerMessage) sendChar(cible.charId, "tombe au sol");
setState(cible, 'renverse', true, evt);
return critique; //Pour les DM en plus
},
penalitePlusPetit: true,
verbe: 'renverser'
},
repousser: {
appliquer: function(attaquant, cible, critique, evt, envoyerMessage) {
var distance = rollDePlus(6);
if (critique && distance < 3) distance = 3;
if (envoyerMessage)
sendChar(cible.charId, "est repoussé" + onGenre(cible.charId, '', 'e') + " et doit reculer de " + distance.roll + "m.");
if (critique) setState(cible, 'renverse', true, evt);
},
penalitePlusPetit: true,
verbe: 'repousser'
},
tenirADistance: {
appliquer: appliquerTenirADistance,
verbe: 'tenir à distance'
}
};
//!cof-appliquer-manoeuvre id1 id2 effet attrId
//attrId est utilisé pour limiter le nombre d'utilisations
function appliquerManoeuvre(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 5) {
error("cof-appliquer-manoeuvre attend 4 arguments", msg.content);
return;
}
var limiteAttr = getObj('attribute', cmd[4]);
if (limiteAttr === undefined) {
sendPlayer(msg, "La manoeuvre a déjà été choisie");
return;
}
var attaquant = tokenOfId(cmd[1], cmd[1]);
if (attaquant === undefined) {
error("Le premier argument de !cof-appliquer-maneuvre n'est pas un token valide", cmd);
return;
}
var cible = tokenOfId(cmd[2], cmd[2]);
if (cible === undefined) {
error("Le deuxième argument de !cof-appliquer-manoeuvre n'est pas un token valide", cmd);
return;
}
if (!_.has(listeManoeuvres, cmd[3])) {
error("Manoeuvre " + cmd[3] + " inconnue.", cmd);
return;
}
var effet = listeManoeuvres[cmd[3]];
var evt = {
type: 'Application de manoeuvre',
deletedAttributes: [limiteAttr]
};
limiteAttr.remove();
effet.appliquer(attaquant, cible, false, evt, true);
addEvent(evt);
}
//!cof-manoeuvre id1 id2 effet
function manoeuvreRisquee(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 4) {
error("cof-manoeuvre attend 3 arguments", msg.content);
return;
}
var attaquant = tokenOfId(cmd[1], cmd[1]);
if (attaquant === undefined) {
error("Le premier argument de !cof-maneuvre n'est pas un token valide", cmd);
return;
}
attaquant.tokName = attaquant.token.get('name');
var cible = tokenOfId(cmd[2], cmd[2]);
if (cible === undefined) {
error("Le deuxième argument de !cof-manoeuvre n'est pas un token valide", cmd);
return;
}
cible.tokName = cible.token.get('name');
if (!_.has(listeManoeuvres, cmd[3])) {
sendPlayer(msg, "Manoeuvre " + cmd[3] + " inconnue.");
return;
}
var effet = listeManoeuvres[cmd[3]];
var evt = {
type: 'manoeuvre'
};
if (effet.penalitePlusPetit) {
var tailleAttaquant = taillePersonnage(attaquant);
var tailleCible = taillePersonnage(cible);
if (tailleAttaquant && tailleCible && tailleAttaquant < tailleCible) {
var penalite = 5 * (tailleAttaquant - tailleCible);
options.bonusAttaqueAttaquant = [{
val: penalite,
explication: attaquant.tokName + " est plus petit que " + cible.tokName + " => " + penalite + " Att"
}];
}
}
var playerId = getPlayerIdFromMsg(msg);
attaqueContactOpposee(playerId, attaquant, cible, evt, options,
function(res, display, explications) {
var dmSupp;
if (res.succes) {
addLineToFramedDisplay(display, attaquant.tokName + " réussi à " + effet.verbe + " " + cible.tokName);
dmSupp = effet.appliquer(attaquant, cible, res.critique, evt);
} else {
addLineToFramedDisplay(display, attaquant.tokName + " ne réussi pas à " + effet.verbe + " " + cible.tokName);
//Envoyer à la cible la possibilité d'appliquer un effet de son choix
}
explications.forEach(function(expl) {
addLineToFramedDisplay(display, expl, 80);
});
if (dmSupp) {
addLineToFramedDisplay(display, attaquant.tokName + " fait en plus des dégâts à " + cible.tokName + " (lancer une attaque pour déterminer le montant)", 80);
setTokenAttr(attaquant, 'attaqueGratuiteAutomatique(' + cible.token.id + ')', true, evt);
}
sendChat("", endFramedDisplay(display));
addEvent(evt);
/*if (dmSupp) {
turnAction(attaquant, playerId);
}*/
if (!res.succes) {
var charCible = getObj('character', cible.charId);
if (charCible === undefined) {
error("Cible sans personnage associé", cible);
return;
}
var nomCible = charCible.get('name');
var titre = "Choisir un effet contre " + attaquant.tokName;
//On crée un display sans le header
display = startFramedDisplay(undefined, titre, cible, {
retarde: true
});
//Attribut pour empecher plusieurs utilisations
var attrLimit = createObj('attribute', {
_characterid: cible.charId,
name: 'limiteApplicationManoeuvre',
current: '1'
});
for (var man in listeManoeuvres) {
var appliquerManoeuvre = '!cof-appliquer-manoeuvre ' + cible.token.id + ' ' + attaquant.token.id + ' ' + man + ' ' + attrLimit.id;
var ligneManoeuvre = boutonSimple(appliquerManoeuvre, '', man);
addLineToFramedDisplay(display, ligneManoeuvre, 90);
}
// on envoie la liste aux joueurs qui gèrent le voleur
var playerIds = getPlayerIds(cible);
playerIds.forEach(function(playerid) {
addFramedHeader(display, playerid, true);
sendChat('', endFramedDisplay(display));
});
if (playerIds.length === 0) {
addFramedHeader(display, undefined, 'gm');
sendChat('', endFramedDisplay(display));
}
}
});
}
function sendCommands(from, commands) {
if (commands.length === 0) return;
var c = commands.shift();
if (c.startsWith('!')) {
_.delay(function() {
sendChat(from, c);
sendCommands(from, commands);
}, 10);
} else error("multi-commande invalide", c);
}
//!cof-multi-command !cmd1 ... --cof-multi-command !cmd2 .. --cof-multi-command !cmd3...
function multiCommand(msg) {
var posFirstCommand = msg.content.indexOf('!', 2);
var commands = msg.content.substr(posFirstCommand).split(' --cof-multi-command ');
sendCommands(msg.who, commands);
/* commands.forEach(function(c) {
if (c.startsWith('!')) sendChat(msg.who, c);
else error("multi-commande invalide", c);
});*/
}
function createCharacter(nom, playerId, avatar, token, spec) {
var res = createObj('character', {
name: nom,
avatar: avatar,
controlledby: playerId
});
if (!res) return;
var charId = res.id;
if (token) {
token.set('represents', charId);
}
var attrs = findObjs({
_type: 'attribute',
_characterid: charId,
});
var attrVersion =
attrs.find(function(a) {
return a.get('name') == 'VERSION';
});
if (!attrVersion) {
createObj('attribute', {
_characterid: charId,
name: 'VERSION',
current: '3.0'
});
}
var pnj = true;
if (spec.attributesFiche) {
if (spec.attributesFiche.type_personnage == 'PJ') pnj = false;
for (var attrName in spec.attributesFiche) {
/*jshint loopfunc: true */
var attr =
attrs.filter(function(a) {
return a.get('name') == attrName;
});
if (attr.length === 0) {
createObj('attribute', {
_characterid: charId,
name: attrName,
current: spec.attributesFiche[attrName]
});
} else {
attr[0].set('current', spec.attributesFiche[attrName]);
}
}
} //end attributesFiche
if (spec.pv) {
var pvAttr = attrs.filter(function(a) {
return a.get('name').toUpperCase() == 'PV';
});
if (pvAttr.length === 0) {
pvAttr = createObj('attribute', {
_characterid: charId,
name: 'PV',
current: spec.pv,
max: spec.pv
});
} else {
pvAttr = pvAttr[0];
pvAttr.set('current', spec.pv);
pvAttr.set('max', spec.pv);
}
if (pnj) {
pvAttr = attrs.filter(function(a) {
return a.get('name').toUpperCase() == 'pnj_pv';
});
if (pvAttr.length === 0) {
pvAttr = createObj('attribute', {
_characterid: charId,
name: 'pnj_pv',
current: spec.pv,
max: spec.pv
});
} else {
pvAttr = pvAttr[0];
pvAttr.set('current', spec.pv);
pvAttr.set('max', spec.pv);
}
}
if (token) {
token.set('bar1_link', pvAttr.id);
token.set('bar1_value', spec.pv);
token.set('bar1_max', spec.pv);
}
}
var actions = "";
if (spec.actions) actions = spec.actions;
if (spec.attaques) {
spec.attaques.forEach(function(att) {
if (!att.length) {
error("Attaque mal formée", att);
} else {
createObj('ability', {
_characterid: charId,
name: att[0],
istokenaction: true,
action: '!cof-attack @{selected|token_id} @{target|token_id} ' + JSON.stringify(att)
});
actions += '%' + att[0] + ' ';
}
});
}
if (spec.attributes) {
spec.attributes.forEach(function(a) {
a._characterid = charId;
createObj('attribute', a);
});
}
if (spec.abilities) {
spec.abilities.forEach(function(a) {
a._characterid = charId;
a.istokenaction = true;
createObj('ability', a);
actions += '%' + a.name + ' ';
});
}
createObj('ability', {
_characterid: charId,
name: '#Actions#',
istokenaction: false,
action: actions
});
return res;
}
var predateurs = {
loup: {
nom: 'Loup',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59094468/bX_aTjrVAbIRHjpRn-HwdQ/max.jpg?1532611383",
token: "https://s3.amazonaws.com/files.d20.io/images/59489165/3R9Ob68sTiqvNeEhwzwWcg/thumb.png?1533047142",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 1,
FORCE: 12,
pnj_for: 1,
DEXTERITE: 12,
pnj_dex: 1,
CONSTITUTION: 12,
pnj_con: 1,
CON_SUP: '@{jetsup}',
pnj_con_sup: 'on',
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 14,
pnj_sag: 2,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 6,
pnj_cha: -2,
DEFDIV: 3,
pnj_def: 14,
pnj_init: 12,
RACE: 'loup',
TAILLE: 'moyen'
},
pv: 9,
attaques: [
['Morsure', ["@{selected|ATKCAC}", 0], 20, [1, 6, 1, 0],
[0]
]
],
attributes: [],
abilities: []
},
loupAlpha: {
nom: 'Loup alpha',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59094818/J0yWdxryZFKakJtNGJNNvw/max.jpg?1532612061",
token: "https://s3.amazonaws.com/files.d20.io/images/60183959/QAMH6WtyoK78aa4zX_mR_Q/thumb.png?1533898482",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 2,
FORCE: 16,
pnj_for: 3,
DEXTERITE: 12,
pnj_dex: 1,
CONSTITUTION: 16,
pnj_con: 3,
CON_SUP: '@{jetsup}',
pnj_con_sup: 'on',
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 14,
pnj_sag: 2,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 6,
pnj_cha: -2,
DEFDIV: 4,
pnj_def: 15,
INIT_DIV: 5,
pnj_init: 17,
RACE: 'loup',
TAILLE: 'moyen'
},
pv: 15,
attaques: [
['Morsure', ["@{selected|ATKCAC}", -1], 20, [1, 6, 3, 0],
[0]
]
],
attributes: [{
name: 'discrétion',
current: 5
}],
abilities: [{
name: 'Embuscade',
action: '!cof-surprise [[15 + @{selected|DEX}]]'
}, {
name: 'Attaque-embuscade',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-1],20,[1,6,3,0],[0]] --sournoise 1 --if moins FOR --etat renverse --endif'
}]
},
worg: {
nom: 'Grand loup',
avatar: "https://s3.amazonaws.com/files.d20.io/images/25294798/4dJ_60uP2mw6UJA2elkoXA/max.jpg?1479223790",
token: "https://s3.amazonaws.com/files.d20.io/images/60184237/smG5o2-siD2pChhPblO_sQ/thumb.png?1533899118",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 3,
FORCE: 16,
pnj_for: 3,
DEXTERITE: 12,
pnj_dex: 1,
CONSTITUTION: 16,
pnj_con: 3,
CON_SUP: '@{jetsup}',
pnj_con_sup: 'on',
INTELLIGENCE: 4,
pnj_int: -3,
SAGESSE: 14,
pnj_sag: 2,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 6,
pnj_cha: -2,
DEFDIV: 6,
pnj_def: 17,
INIT_DIV: 5,
pnj_init: 17,
RACE: 'loup',
TAILLE: 'moyen'
},
pv: 35,
attaques: [
['Morsure', ["@{selected|ATKCAC}", 0], 20, [1, 6, 5, 0],
[0]
]
],
attributes: [{
name: 'discrétion',
current: 5
}],
abilities: [{
name: 'Embuscade',
action: '!cof-surprise [[15 + @{selected|DEX}]]'
}, {
name: 'Attaque-embuscade',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",0],20,[1,6,5,0],[0]] --sournoise 1 --if moins FOR --etat renverse --endif'
}]
},
lion: {
nom: 'Lion',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59486104/SngxPIGXDJKdCqsbrXxRYQ/max.jpg?1533041390",
token: "https://s3.amazonaws.com/files.d20.io/images/60184437/df1MT2T6lrfo7st02Htxeg/thumb.png?1533899407",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 4,
FORCE: 20,
pnj_for: 5,
DEXTERITE: 18,
pnj_dex: 4,
DEX_SUP: '@{jetsup}',
pnj_dex_sup: 'on',
CONSTITUTION: 20,
pnj_con: 5,
INTELLIGENCE: 4,
pnj_int: -3,
SAGESSE: 14,
pnj_sag: 2,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 6,
pnj_cha: -3,
DEFDIV: 4,
pnj_def: 18,
INIT_DIV: 5,
pnj_init: 23,
RACE: 'lion',
TAILLE: 'grand'
},
pv: 30,
attaques: [
['Morsure', ["@{selected|ATKCAC}", -1], 20, [2, 6, 5, 0],
[0]
]
],
attributes: [{
name: 'discrétion',
current: 5
}],
abilities: [{
name: 'Embuscade',
action: '!cof-surprise [[15 + @{selected|DEX}]]'
}, {
name: 'Attaque-embuscade',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-1],20,[2,6,5,0],[0]] --sournoise 1 --if moins FOR --etat renverse --endif --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat immobilise FOR @{selected|token_id} --endif --endif'
}, {
name: 'Dévorer',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-1],20,[2,6,5,0],[0]] --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat renverse --etat immobilise FOR @{selected|token_id} --endif --endif'
}]
},
grandLion: {
nom: 'Grand lion',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59486144/8wHs_5WfEIeL_7dKbALHHA/max.jpg?1533041459",
token: "https://s3.amazonaws.com/files.d20.io/images/60186141/mUZzndi9_sYIzdVVNNka_w/thumb.png?1533903070",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 5,
FORCE: 22,
pnj_for: 6,
DEXTERITE: 18,
pnj_dex: 3,
DEX_SUP: '@{jetsup}',
pnj_dex_sup: 'on',
CONSTITUTION: 20,
pnj_con: 5,
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 14,
pnj_sag: 2,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 14,
pnj_cha: 2,
DEFDIV: 6,
pnj_def: 20,
pnj_init: 18,
RACE: 'lion',
TAILLE: 'grand'
},
pv: 50,
attaques: [
['Morsure', ["@{selected|ATKCAC}", -2], 20, [2, 6, 7, 0],
[0]
]
],
attributes: [{
name: 'discrétion',
current: 5
}],
abilities: [{
name: 'Embuscade',
action: '!cof-surprise [[15 + @{selected|DEX}]]'
}, {
name: 'Attaque-embuscade',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-2],20,[2,6,7,0],[0]] --sournoise 1 --if moins FOR --etat renverse --endif --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat immobilise FOR @{selected|token_id} --endif --endif'
}, {
name: 'Dévorer',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-2],20,[2,6,7,0],[0]] --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat renverse --etat immobilise FOR @{selected|token_id} --endif --endif'
}]
},
oursPolaire: {
nom: 'Ours polaire',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59486216/UssilagWK_2dfVGuPABBpA/max.png?1533041591",
token: "https://s3.amazonaws.com/files.d20.io/images/60186288/B1uAii9G01GcPfQFNozIbw/thumb.png?1533903333",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 6,
FORCE: 26,
pnj_for: 8,
FOR_SUP: '@{jetsup}',
pnj_for_sup: 'on',
DEXTERITE: 11,
pnj_dex: 0,
CONSTITUTION: 26,
pnj_con: 8,
CON_SUP: '@{jetsup}',
pnj_con_sup: 'on',
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 14,
pnj_sag: 2,
CHARISME: 6,
pnj_cha: -2,
DEFDIV: 10,
pnj_def: 20,
pnj_init: 11,
RACE: 'ours',
TAILLE: 'grand'
},
pv: 70,
attaques: [
['Morsure', ["@{selected|ATKCAC}", 0], 20, [2, 8, 7, 0],
[0]
]
],
attributes: [{
name: 'peutEnrager',
current: 'true'
}],
abilities: [{
name: 'Charge',
action: '%{selected|Morsure} --m2d20 --pietine}'
}, ]
},
tigreDentsDeSabre: {
nom: 'Tigre à dents de sabre',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59486272/f5lUcN3Y9H0thmJPrqa6FQ/max.png?1533041702",
token: "https://s3.amazonaws.com/files.d20.io/images/60186469/ShcrgpvgXKiQsLVOyg4SZQ/thumb.png?1533903741",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 7,
FORCE: 26,
pnj_for: 8,
FOR_SUP: '@{jetsup}',
pnj_for_sup: 'on',
DEXTERITE: 18,
pnj_dex: 4,
DEX_SUP: '@{jetsup}',
pnj_dex_sup: 'on',
CONSTITUTION: 26,
pnj_con: 8,
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 12,
pnj_sag: 1,
SAG_SUP: '@{jetsup}',
pnj_sag_sup: 'on',
CHARISME: 2,
pnj_cha: -4,
DEFDIV: 8,
pnj_def: 22,
pnj_init: 18,
RACE: 'tigre',
TAILLE: 'grand'
},
pv: 90,
attaques: [
['Morsure', ["@{selected|ATKCAC}", -1], 20, [2, 6, 12, 0],
[0]
]
],
attributes: [{
name: 'discrétion',
current: 5
}],
abilities: [{
name: 'Embuscade',
action: '!cof-surprise [[15 + @{selected|DEX}]]'
}, {
name: 'Attaque-embuscade',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-1],20,[2,6,12,0],[0]] --sournoise 1 --if moins FOR --etat renverse --endif --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat immobilise FOR @{selected|token_id} --endif --endif'
}, {
name: 'Dévorer',
action: '!cof-attack @{selected|token_id} @{target|token_id} ["Morsure",["@{selected|ATKCAC}",-1],20,[2,6,12,0],[0]] --if deAttaque 15 --message @{selected|token_name} saisit sa proie entre ses crocs et peut faire une attaque gratuite --if moins FOR --etat renverse --etat immobilise FOR @{selected|token_id} --endif --endif'
}]
},
oursPrehistorique: {
nom: 'Ours préhistorique',
avatar: "https://s3.amazonaws.com/files.d20.io/images/59486323/V6RVSlBbeRJi_aIaIuGGBw/max.png?1533041814",
token: "https://s3.amazonaws.com/files.d20.io/images/60186633/lNHXvCOsvfPMZDQnqJKQVw/thumb.png?1533904189",
attributesFiche: {
type_personnage: 'PNJ',
NIVEAU: 8,
FORCE: 32,
pnj_for: 11,
DEXTERITE: 10,
pnj_dex: 0,
CONSTITUTION: 32,
pnj_con: 11,
CON_SUP: '@{jetsup}',
pnj_con_sup: 'on',
INTELLIGENCE: 2,
pnj_int: -4,
SAGESSE: 14,
pnj_sag: 2,
CHARISME: 6,
pnj_cha: -2,
DEFDIV: 12,
pnj_def: 22,
pnj_init: 10,
RDS: 2,
pnj_rd: 2,
RACE: 'ours',
TAILLE: 'énorme'
},
pv: 110,
attaques: [
['Griffes', ["@{selected|ATKCAC}", -2], 20, [3, 6, 13, 0],
[0]
]
],
attributes: [{
name: 'fauchage',
current: 'true'
}],
abilities: [{
name: 'Charge',
action: '%{selected|Griffes} --m2d20 --pietine}'
}, ]
}
};
function conjurationPredateur(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined) {
error("Pas de commande", msg.content);
return;
}
var renforce = 0;
if (cmd.length > 1) {
renforce = parseInt(cmd[1]);
if (isNaN(renforce)) {
error("Il faut un nombre comme premier argument de !cof-conjuration-de-predateur");
renforce = 0;
}
}
getSelected(msg, function(selected, playerId) {
if (selected === undefined || selected.length === 0) {
error("pas de lanceur pour la conjuration de prédateurs", msg);
return;
}
var evt = {
type: 'conjuration de prédateurs'
};
initiative(selected, evt);
iterSelected(selected, function(invocateur) {
var pageId = invocateur.token.get('pageid');
var niveau = ficheAttributeAsInt(invocateur, 'NIVEAU', 1);
if (!renforce) {
renforce = charAttributeAsInt(invocateur, 'voieDeLaConjuration', 0);
if (renforce == 1) renforce = 0;
}
niveau += renforce;
var predateur;
if (niveau < 5) predateur = predateurs.loup;
else if (niveau < 9) predateur = predateurs.loupAlpha;
else if (niveau < 12) predateur = predateurs.worg;
else if (niveau < 15) predateur = predateurs.lion;
else if (niveau < 18) predateur = predateurs.grandLion;
else if (niveau < 21) predateur = predateurs.oursPolaire;
else if (niveau < 23) predateur = predateurs.tigreDentsDeSabre;
else predateur = predateurs.oursPrehistorique;
var nomPredateur =
predateur.nom + ' de ' + invocateur.token.get('name');
var token = createObj('graphic', {
name: nomPredateur,
subtype: 'token',
pageid: pageId,
imgsrc: predateur.token,
left: invocateur.token.get('left'),
top: invocateur.token.get('top'),
width: 70,
height: 70,
layer: 'objects',
showname: 'true',
showplayers_bar1: 'true',
light_hassight: 'true',
light_angle: 0 //Pour que le joueur ne voit rien par ses yeux
});
toFront(token);
var charPredateur =
createCharacter(nomPredateur, playerId, predateur.avatar, token, predateur);
//Tous les prédateurs sont des quadrupèdes
createObj('attribute', {
name: 'quadrupede',
_characterid: charPredateur.id,
current: true
});
//Attribut de predateur conjuré pour la disparition automatique
createObj('attribute', {
name: 'predateurConjure',
_characterid: charPredateur.id,
current: 5 + modCarac(invocateur, 'CHARISME'),
max: getInit()
});
evt.characters = [charPredateur];
evt.tokens = [token];
initiative([{
_id: token.id
}], evt);
}); //end iterSelected
addEvent(evt);
}); //end getSelected
}
//!cof-conjuration-armee [dé de DM] --limiteParJour...
function conjurationArmee(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined) {
error("Problème de parse options", msg.content);
return;
}
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "Il faut sélectionner le lanceur de la conjuration d'arméé");
return;
}
iterSelected(selected, function(invocateur) {
var pageId = invocateur.token.get('pageid');
var niveau = ficheAttributeAsInt(invocateur, 'NIVEAU', 1);
var evt = {
type: "Conjuration d'armée"
};
if (limiteRessources(invocateur, options, 'conjurationArmee', "conjurer une armée", evt)) return;
var deDM;
var nbDeDM;
if (cmd.length > 1) {
var argDe = cmd[1].split(/d/i);
if (argDe.length == 2) {
nbDeDM = parseInt(argDe[0]);
if (isNaN(nbDeDM) || nbDeDM < 1) nbDeDM = undefined;
else {
deDM = parseInt(argDe[1]);
if (isNaN(deDM) || deDM < 1) deDM = undefined;
}
}
}
if (deDM === undefined) {
var rang = charAttributeAsInt(invocateur, 'voieDeLaConjuration', 3);
if (rang <= 3) {
deDM = 6;
nbDeDM = 1;
} else if (rang == 4) {
deDM = 10;
nbDeDM = 1;
} else {
deDM = 6;
nbDeDM = 2;
}
}
var nomArmee = "Armée de " + invocateur.token.get('name');
var token = createObj('graphic', {
name: nomArmee,
subtype: 'token',
pageid: pageId,
imgsrc: 'https://s3.amazonaws.com/files.d20.io/images/73283129/-jrKAyQQ1P7zpD09xeTbXw/thumb.png?1549546953',
left: invocateur.token.get('left'),
top: invocateur.token.get('top'),
width: 70,
height: 70,
layer: 'objects',
showname: 'true',
showplayers_bar1: 'true',
light_hassight: 'true',
light_angle: 0, //Pour que le joueur ne voit rien par ses yeux
aura1_radius: 10,
aura1_color: "#d56eef",
aura1_square: true
});
toFront(token);
var avatar = "https://s3.amazonaws.com/files.d20.io/images/73283254/r6sbxbP1QKKtqXyYq-MlLA/max.png?1549547198";
var attaque = '!cof-attack @{selected|token_id} @{target|token_id} ';
attaque += '["Attaque",["@{selected|ATKCAC}",0],20,[' + nbDeDM + ',' + deDM + ',0,0],[20]] --auto';
var abilities = [{
name: 'Attaque',
action: attaque
}];
var attributes = [{
name: 'armeeConjuree',
current: invocateur.charId
}];
var charArmee =
createCharacter(nomArmee, playerId, avatar, token, {
pv: niveau * 10,
abilities: abilities,
attributes: attributes
});
evt.characters = [charArmee];
evt.tokens = [token];
if (stateCOF.combat) {
initiative([{
_id: token.id
}], evt);
}
});
});
}
//Crée les macros utiles au jeu
var gameMacros = [{
name: 'Actions',
action: "!cof-liste-actions",
visibleto: 'all',
istokenaction: true
}, {
name: 'Attaque',
action: "!cof-attack @{selected|token_id} @{target|token_id}",
visibleto: 'all',
istokenaction: false
}, {
name: 'Consommables',
action: "!cof-consommables",
visibleto: 'all',
istokenaction: true
}, {
name: 'Monter',
action: "!cof-escalier haut",
visibleto: 'all',
istokenaction: true,
inBar: false
}, {
name: 'Descendre',
action: "!cof-escalier bas",
visibleto: 'all',
istokenaction: true,
inBar: false
}, {
name: 'Fin-combat',
action: "!cof-fin-combat",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Init',
action: "!cof-init",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Jets',
action: "!cof-jet",
visibleto: 'all',
istokenaction: true,
}, {
name: 'Jets-GM',
action: "!cof-jet --secret",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Nuit',
action: "!cof-nouveau-jour ?{Repos?|Oui,--repos|Non}",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Repos',
action: "!cof-recuperation",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Statut',
action: "!cof-statut",
visibleto: 'all',
istokenaction: true
}, {
name: 'Surprise',
action: "!cof-surprise ?{difficulté}",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'Torche',
action: "!cof-torche @{selected|token_id}",
visibleto: 'all',
istokenaction: true,
}, {
name: 'Éteindre',
action: "!cof-eteindre-lumiere ?{Quelle lumière?|Tout}",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'devient',
action: "!cof-set-state ?{État|mort|surpris|assome|renverse|aveugle|affaibli|etourdi|paralyse|ralenti|immobilise|endormi|apeure|invisible|blessé|encombre} true",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'enlève',
action: "!cof-set-state ?{État|mort|surpris|assome|renverse|aveugle|affaibli|etourdi|paralyse|ralenti|immobilise|endormi|apeure|invisible|blessé|encombre} false",
visibleto: '',
istokenaction: false,
inBar: true
}, {
name: 'undo',
action: "!cof-undo",
visibleto: '',
istokenaction: false,
inBar: true
}, ];
function setGameMacros(msg) {
var playerId = msg.playerid;
var force = playerIsGM(playerId) && msg.content.includes('--force');
var inBar = [];
var allMacros = findObjs({
_type: 'macro'
});
gameMacros.forEach(function(m) {
var prev =
allMacros.find(function(macro) {
return macro.get('name') == m.name;
});
if (prev === undefined) {
m.playerid = playerId;
createObj('macro', m);
sendPlayer(msg, "Macro " + m.name + " créée.");
if (m.inBar) inBar.push(m.name);
} else if (force) {
prev.set('action', m.action);
prev.set('visibleto', m.visibleto);
prev.set('istokenaction', m.istokenaction);
sendPlayer(msg, "Macro " + m.name + " réécrite.");
if (m.inBar) inBar.push(m.name);
} else {
sendPlayer(msg, "Macro " + m.name + " déjà présente (utiliser --force pour réécrire).");
}
});
if (inBar.length > 0) {
sendPlayer(msg, "Macros à mettre dans la barre d'action du MJ : " + inBar.join(', '));
}
stateCOF.gameMacros = gameMacros;
}
function ajouteLumiere(msg) {
var options = parseOptions(msg);
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("Il faut au moins 2 arguments à !cof-lumiere", cmd);
return;
}
var cible = tokenOfId(cmd[1]);
if (cible === undefined) {
error("le premier argument de !cof-lumière doit être un token", cmd);
return;
}
var radius = parseInt(cmd[2]);
if (isNaN(radius) || radius <= 0) {
error("La distance de vue de la lumière doit être positive", cmd[2]);
return;
}
var dimRadius = '';
if (cmd.length > 3) {
dimRadius = parseInt(cmd[3]);
if (isNaN(dimRadius)) {
error("La distance de vue de la lumière assombrie doit être un nombre", cmd[3]);
dimRadius = '';
}
}
var nomToken = 'lumiere';
if (cmd.length > 4) {
nomToken = cmd[4].trim();
if (nomToken === '') nomToken = 'lumiere';
}
var evt = {
type: 'lumiere',
};
ajouteUneLumiere(cible, nomToken, radius, dimRadius, evt);
addEvent(evt);
}
function ajouteUneLumiere(perso, groupe, radius, dimRadius, evt) {
var ct = perso.token;
var attrName = 'lumiere';
if (ct.get('bar1_link') === "") attrName += "_" + ct.get('name');
var nomLumiere = groupe + '_' + ct.get('name');
if (ct.get('bar1_max') && !ct.get('light_radius')) {
//Cas particulier où le personnage est un vrai personnage qui ne fait pas de lumière
setToken(ct, 'light_radius', radius, evt);
if (dimRadius !== '') setToken(ct, 'light_dimradius', dimRadius, evt);
setToken(ct, 'light_otherplayers', true, evt);
var attr1 = createObj('attribute', {
characterid: perso.charId,
name: attrName,
current: nomLumiere,
max: 'surToken'
});
evt.attributes = [{
attribute: attr1,
current: null
}];
return;
}
var pageId = ct.get('pageid');
var tokLumiere = createObj('graphic', {
_pageid: pageId,
imgsrc: "https://s3.amazonaws.com/files.d20.io/images/3233035/xHOXBXoAgOHCHs8omiFAYg/thumb.png?1393406116",
left: ct.get('left'),
top: ct.get('top'),
width: 70,
height: 70,
layer: 'walls',
name: nomLumiere,
light_radius: radius,
light_dimradius: dimRadius,
light_otherplayers: true
});
if (tokLumiere === undefined) {
error("Problème lors de la création du token de lumière", perso);
return;
}
evt.tokens = [tokLumiere];
if (ct.get('bar1_max')) { //Lumière liée à un token
var attr = createObj('attribute', {
characterid: perso.charId,
name: attrName,
current: nomLumiere,
max: tokLumiere.id
});
evt.attributes = [{
attribute: attr,
current: null
}];
} else { //cible temporaire, à effacer7
ct.remove();
}
}
function eteindreUneLumiere(perso, pageId, al, lumName, evt) {
var lumId = al.get('max');
if (lumId == 'surToken') {
setToken(perso.token, 'light_radius', '', evt);
setToken(perso.token, 'light_dimradius', '', evt);
al.remove();
return;
}
var lumiere = getObj('graphic', lumId);
if (lumiere === undefined) {
var tokensLumiere = findObjs({
_type: 'graphic',
_pageid: pageId,
layer: 'walls',
name: lumName
});
if (tokensLumiere.length === 0) {
log("Pas de token pour la lumière " + lumName);
al.remove();
return;
}
lumiere = tokensLumiere.shift();
if (tokensLumiere.length > 0) {
//On cherche le token le plus proche de perso
var pos = [perso.token.get('left'), perso.token.get('top')];
var d =
VecMath.length(
VecMath.vec([lumiere.get('left'), lumiere.get('top')], pos));
tokensLumiere.forEach(function(tl) {
var d2 =
VecMath.length(
VecMath.vec([tl.get('left'), tl.get('top')], pos));
if (d2 < d) {
d = d2;
lumiere = tl;
}
});
}
}
al.remove();
if (lumiere) lumiere.remove();
}
function eteindreLumieres(msg) {
var options = parseOptions(msg);
getSelected(msg, function(selected) {
if (selected.length === 0) {
sendPlayer(msg, "Pas de cible sélectionnée pour !cof-eteindre-lumiere");
return;
}
var cmd = options.cmd;
var groupe;
if (cmd.length > 1) groupe = cmd[1];
if (groupe && groupe.toLowerCase() == 'tout') groupe = '';
var pageId = options.pageId;
var evt = {
type: "Eteindre la lumière"
};
iterSelected(selected, function(perso) {
var attrLumiere = tokenAttribute(perso, 'lumiere');
attrLumiere.forEach(function(al) {
var lumName = al.get('current');
if (groupe && !lumName.startsWith(groupe)) return;
eteindreUneLumiere(perso, pageId, al, lumName, evt);
});
});
}, options);
}
function switchTorche(msg) {
var options = parseOptions(msg);
var cmd = options.cmd;
if (cmd.length < 2) {
error("Il faut préciser le token en argument de !cof-torche");
return;
}
var pageId = options.pageId;
var perso = tokenOfId(cmd[1], cmd[1], pageId);
if (perso === undefined) {
error("Token invalide", cmd);
return;
}
var diminueDuree = 0;
if (cmd.length > 2) {
//Dans ce cas, c'est pour diminuer la durée de vie de la torche
diminueDuree = parseInt(cmd[2]);
if (isNaN(diminueDuree) || diminueDuree <= 0) {
sendPlayer(msg, "Le deuxième argument de !cof-torche doit être un nombre strictement positif " + msg.content);
return;
}
}
var evt;
//On commence par chercher si une torche est allumée
var torcheAllumee = false;
var attrLumiere = tokenAttribute(perso, 'lumiere').filter(function(a) {
return a.get('current').startsWith('torche');
});
if (!diminueDuree && attrLumiere.length > 0) {
torcheAllumee = true;
evt = {
type: "Éteindre les torches"
};
attrLumiere.forEach(function(al) {
var lumName = al.get('current');
eteindreUneLumiere(perso, pageId, al, lumName, evt);
});
}
var nbTorches = 0;
var tempsTorche = 0;
var attrTorches = tokenAttribute(perso, 'torches');
if (attrTorches.length > 0) {
nbTorches = parseInt(attrTorches[0].get('current'));
if (isNaN(nbTorches) || nbTorches < 0) {
error("Nombre de torches incorrect", nbTorches);
if (evt) addEvent(evt);
return;
}
if (!torcheAllumee && nbTorches === 0) {
whisperChar(perso.charId, "n'a pas de torche.");
return;
}
tempsTorche = parseInt(attrTorches[0].get('max'));
if (isNaN(tempsTorche) || tempsTorche < 0) {
error("Temps restant pour la torche incorrect", tempsTorche);
if (evt) addEvent(evt);
return;
}
if (tempsTorche === 0) {
if (nbTorches === 0) { //Donc forcément torcheAllumee
//On remet l'attribut dans un état convenable
setTokenAttr(perso, 'torches', 0, evt, undefined, 60);
addEvent(evt);
return;
}
nbTorches--;
tempsTorche = 60;
}
if (diminueDuree) {
evt = evt || {
type: "Diminuer le duree de vie d'une torche"
};
var temps = diminueDuree;
tempsTorche -= diminueDuree;
if (tempsTorche <= 0) {
nbTorches--;
temps += tempsTorche;
tempsTorche = 60;
var msgDiminue = "torche épuisée.";
if (nbTorches === 0) {
msgDiminue += " Plus de torche !";
} else if (nbTorches == 1) {
msgDiminue += " Plus qu'une torche.";
} else {
msgDiminue += " Il lui reste " + nbTorches + " torches.";
}
whisperChar(perso.charId, msgDiminue);
}
setTokenAttr(perso, 'torches', nbTorches, evt, undefined, tempsTorche);
sendChar(perso.charId, '/w gm temps de torche diminué de ' + temps + ' minutes');
addEvent(evt);
return;
}
if (torcheAllumee) {
sendChar(perso.charId,
"/w gm torche éteinte. Reste " + nbTorches + " torches, et " +
tempsTorche + " minutes pour la dernière. " +
boutonSimple("!cof-torche " + perso.token.id + " ?{Durée?}", '', "Temps depuis allumage"));
addEvent(evt);
return;
}
evt = {
type: "Allumer une torche"
};
ajouteUneLumiere(perso, 'torche', 13, 7, evt);
var msgAllume =
"allume une torche, qui peut encore éclairer pendant " + tempsTorche +
" minute";
if (tempsTorche > 1) msgAllume += 's';
msgAllume += '.';
if (nbTorches > 1) {
msgAllume += " Il lui reste encore " + (nbTorches - 1);
if (nbTorches == 2) msgAllume += " autre torche.";
else msgAllume += " autres torches.";
}
whisperChar(perso.charId, msgAllume);
addEvent(evt);
return;
}
//On ne tient pas le compte précis des torches
if (torcheAllumee) {
whisperChar(perso.charId, "éteint sa torche");
} else {
evt = {
type: "Allumer une torche"
};
ajouteUneLumiere(perso, 'torche', 13, 7, evt);
whisperChar(perso.charId, "allume sa torche");
}
addEvent(evt);
}
//!cof-options
//!cof-options opt1 [... optn] val, met l'option à val
//!cof-options [opt0 ... optk] reset remet toutes les options à leur valeur patr défaut
//Dans tous les cas, affiche les options du niveau demandé
function setCofOptions(msg) {
var playerId = getPlayerIdFromMsg(msg);
if (!playerIsGM(playerId)) {
sendPlayer(msg, "Seul le MJ peut changer les options du script");
return;
}
var cmd = msg.content.split(' ');
var cofOptions = stateCOF.options;
if (cofOptions === undefined) {
sendPlayer(msg, "Options non diponibles");
return;
}
var prefix = '';
var up;
var defOpt = defaultOptions;
var newOption;
var lastCmd;
var fini;
cmd.shift();
cmd.forEach(function(c) {
if (fini) {
sendPlayer(msg, "Option " + c + " ignorée");
return;
}
if (c == 'reset') {
for (var opt in cofOptions) delete cofOptions[opt];
copyOptions(cofOptions, defOpt);
fini = true;
} else if (cofOptions[c]) {
if (cofOptions[c].type == 'options') {
if (defOpt[c] === undefined) {
sendPlayer(msg, "Option " + c + " inconnue dans les options par défaut");
fini = true;
return;
}
defOpt = defOpt[c].val;
cofOptions = cofOptions[c].val;
up = prefix;
prefix += ' ' + c;
} else {
newOption = cofOptions[c];
}
} else {
if (newOption) { //on met newOption à c
var val = c;
switch (newOption.type) {
case 'bool':
switch (c) {
case 'oui':
case 'true':
case '1':
val = true;
break;
case 'non':
case 'false':
case '0':
val = false;
break;
default:
sendPlayer(msg, "L'option " + lastCmd + " ne peut être que true ou false");
val = newOption.val;
}
break;
case 'int':
val = parseInt(c);
if (isNaN(val)) {
sendPlayer(msg, "L'option " + lastCmd + " est une valeur entière");
val = newOption.val;
}
break;
}
newOption.val = val;
fini = true;
} else if (lastCmd) {
sendPlayer(msg, "L'option " + lastCmd + " ne contient pas de sous-option " + c);
} else {
sendPlayer(msg, "Option " + c + " inconnue.");
}
}
lastCmd = c;
});
var titre = "Options de COFantasy";
if (prefix !== '') {
titre += "<br>" + prefix + ' (';
titre += boutonSimple('!cof-options' + up, '', 'retour') + ')';
}
var display = startFramedDisplay(playerId, titre, undefined, {
chuchote: true
});
for (var opt in cofOptions) {
var optVu = opt.replace(/_/g, ' ');
var line = '<span title="' + cofOptions[opt].explications + '">' +
optVu + '</span> : ';
var action = '!cof-options' + prefix + ' ' + opt;
var displayedVal = cofOptions[opt].val;
var after = '';
switch (cofOptions[opt].type) {
case 'options':
displayedVal = '<span style="font-family: \'Pictos\'">l</span>';
break;
case 'bool':
action += ' ?{Nouvelle valeur de ' + optVu + '|actif,true|inactif,false}';
if (displayedVal)
// Bizarrement, le caractère '*' modifie la suite du tableau
displayedVal = '<span style="font-family: \'Pictos\'">3</span>';
else
displayedVal = '<span style="font-family: \'Pictos\'">*</span>';
break;
case 'int':
action += ' ?{Nouvelle valeur de ' + optVu + '(entier)}';
break;
case 'image':
action += " ?{Entrez l'url pour " + optVu + '}';
after =
'<img src="' + displayedVal + '" style="width: 30%; height: auto; border-radius: 6px; margin: 0 auto;">';
displayedVal = '<span style="font-family: \'Pictos\'">u</span>';
break;
default:
action += ' ?{Nouvelle valeur de ' + optVu + '}';
}
line += boutonSimple(action, '', displayedVal) + after;
addLineToFramedDisplay(display, line);
}
addLineToFramedDisplay(display, boutonSimple('!cof-options' + prefix + ' reset', '', 'Valeurs par défaut'), 70);
sendChat('', endFramedDisplay(display));
}
function lancerDefiSamourai(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("cof-defi-samourai demande au moins 2 options",
msg.content);
return;
}
var pageId = options.pageId;
var samourai = tokenOfId(cmd[1], cmd[1], pageId);
if (samourai === undefined) {
error("Le token sélectionné n'est pas valide", msg.content);
return;
}
samourai.tokName = samourai.token.get('name');
if (attributeAsBool(samourai, 'defiSamourai')) {
sendPlayer(msg, samourai.tokName + " a déjà lancé un défi durant ce combat.");
return;
}
var cible = tokenOfId(cmd[2], cmd[2], pageId);
if (cible === undefined) {
error("Le deuxième token sélectionné n'est pas valide", msg.content);
return;
}
cible.tokName = cible.token.get('name');
var evt = {
type: 'Défi samouraï'
};
var explications = [];
entrerEnCombat(samourai, [cible], explications, evt);
explications.forEach(function(m) {
sendChar(samourai.charId, m);
});
var bonus;
if (cmd.length > 3) {
bonus = parseInt(cmd[3]);
if (isNaN(bonus) || bonus < 1) {
error("Bonus de défi de samouraï incorrect", cmd[3]);
bonus = undefined;
}
}
if (bonus === undefined)
bonus = charAttributeAsInt(samourai, 'voieDeLHonneur', 2);
setTokenAttr(samourai, 'defiSamourai', bonus, evt,
samourai.tokName + " lance un défi à " + cible.tokName,
cible.token.id + ' ' + cible.tokName);
}
//!cof-enveloppement cubeId targetId Difficulte Attaque
//Attaque peut être soit label l, soit ability a
function enveloppement(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined) {
error("Problème de parse options", msg.content);
return;
}
if (cmd.length < 6) {
error("Il manque des arguments à !cof-enveloppement", cmd);
return;
}
var cube = tokenOfId(cmd[1]);
if (cube === undefined) {
error("Token non défini", cmd[1]);
return;
}
if (!peutController(msg, cube)) {
sendPlayer(msg, "pas le droit d'utiliser ce bouton");
return;
}
var cible = tokenOfId(cmd[2]);
if (cible === undefined) {
error("Token non défini", cmd[2]);
return;
}
var difficulte = parseInt(cmd[3]);
if (isNaN(difficulte)) {
error("Difficulté n'est pas un nombre, on prend 15 par défaut", cmd[3]);
difficulte = 15;
}
var exprDM;
switch (cmd[4]) {
case 'label':
case 'ability':
exprDM = cmd[4] + ' ' + cmd[5];
break;
default:
error("Impossible de déterminer les dégâts quand enveloppé", cmd[4]);
return;
}
var evt = {
type: 'Enveloppement'
};
//Choix de la caractéristique pour résister : FOR ou DEX
var caracRes = meilleureCarac('FOR', 'DEX', cible, 10 + modCarac(cube, 'FORCE'));
var titre = "Enveloppement";
var display = startFramedDisplay(options.playerId, titre, cube, {
perso2: cible
});
var explications = [];
testOppose(cube, 'FOR', cible, caracRes, explications, evt,
function(res, crit) {
switch (res) {
case 1:
explications.push(cube.token.get('name') + " a absorbé " + cible.token.get('name'));
var cubeId = cube.token.id + ' ' + cube.token.get('name');
setTokenAttr(cible, 'enveloppePar', cubeId, evt, undefined, difficulte);
var cibleId = cible.token.id + ' ' + cible.token.get('name');
cible.token.set('left', cube.token.get('left'));
cible.token.set('right', cube.token.get('right'));
toFront(cube.token);
setTokenAttr(cube, 'enveloppe', cibleId, evt, undefined, exprDM);
break;
case 2:
if (caracRes == 'FOR') {
explications.push(cible.token.get('name') + " résiste et ne se laisse pas absorber");
} else {
explications.push(cible.token.get('name') + " évite l'absorption");
}
break;
default: //match null, la cible s'en sort
explications.push(cible.token.get('name') + " échappe de justesse à l'enveloppement");
}
explications.forEach(function(e) {
addLineToFramedDisplay(display, e);
});
addEvent(evt);
sendChat("", endFramedDisplay(display));
}
);
}
//!cof-echapper-enveloppement
function echapperEnveloppement(msg) {
var options = msg.options || parseOptions(msg);
if (options === undefined) return;
var evt = {
type: "Tentative de sortie d'enveloppement"
};
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "!cof-echapper-enveloppement sans sélection de token");
log("!cof-echapper-enveloppement requiert de sélectionner des tokens");
return;
}
iterSelected(selected, function(perso) {
var attr = tokenAttribute(perso, 'enveloppePar');
if (attr.length === 0) {
sendPlayer(msg, perso.token.get('name') + " n'est pas englouti.");
return;
}
attr = attr[0];
var cube = tokenOfIdName(attr.get('current'), options.pageId);
if (cube === undefined) {
error("Attribut enveloppePar mal formé, on le supprime", attr.get('current'));
attr.remove();
return;
}
var difficulte = parseInt(attr.get('max'));
if (isNaN(difficulte)) {
error("Difficulté mal formée", attr.get('max'));
difficulte = 15;
}
var titre = "Tentative de sortir de " + cube.tokName;
var display = startFramedDisplay(playerId, titre, perso, {
chuchote: options.secret
});
if (options.chance) options.bonus = options.chance * 10;
testCaracteristique(perso, 'FOR', difficulte, options, evt,
function(tr) {
addLineToFramedDisplay(display, "<b>Résultat :</b> " + tr.texte);
addEvent(evt);
if (tr.reussite) {
addLineToFramedDisplay(display, "C'est réussi, " + perso.token.get('name') + " s'extirpe de " + cube.tokName);
toFront(perso.token);
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attr);
attr.remove();
attr = tokenAttribute(cube, 'enveloppe');
attr.forEach(function(a) {
var ca = tokenOfIdName(a.get('current'));
if (ca && ca.token.id == perso.token.id) {
evt.deletedAttributes.push(a);
a.remove();
}
});
} else if (selected.length == 1) {
//TODO : ajouter le pacte sanglant, la prouesse et le tour de force
var msgRate = "C'est raté.";
evt.personnage = perso;
evt.action = {
selected: [{
_id: perso.token.id
}],
playerId: playerId,
options: options
};
evt.type = 'echapperEnveloppement';
var pc = ficheAttributeAsInt(perso, 'PC', 0);
if (pc > 0) {
options.roll = options.roll || tr.roll;
msgRate += ' ' +
bouton("!cof-bouton-chance " + evt.id, "Chance", perso) +
" (reste " + pc + " PC)";
}
if (charAttributeAsBool(perso, 'runeDEnergie')) {
msgRate += ' ' + bouton("!cof-bouton-rune-energie " + evt.id, "Rune d'énergie", perso);
}
addLineToFramedDisplay(display, msgRate);
}
sendChat('', endFramedDisplay(display));
});
});
addEvent(evt);
});
}
//!cof-liberer-agrippe
function libererAgrippe(msg) {
var options = msg.options || parseOptions(msg);
if (options === undefined) return;
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "fonction !cof-liberer-agrippe sans sélection de token");
log("!cof-liberer-agrippe requiert de sélectionner des tokens");
return;
}
iterSelected(selected, function(perso) {
var attr = tokenAttribute(perso, 'estAgrippePar');
perso.tokName = perso.token.get('name');
if (attr.length === 0) {
sendPlayer(msg, perso.tokName + " n'est pas agrippé.");
return;
}
attr = attr[0];
var agrippant = tokenOfIdName(attr.get('current'), options.pageId);
if (agrippant === undefined) {
error("Attribut estAgrippePar mal formé, on le supprime", attr.get('current'));
attr.remove();
return;
}
var evt = {
type: "Tentative de se libérer"
};
var titre = "Tentative de se libérer de " + agrippant.tokName;
var display = startFramedDisplay(playerId, titre, perso, {
chuchote: options.secret
});
var explications = [];
if (options.chance) options.bonus = options.chance * 10;
testOppose(perso, 'FOR', agrippant, 'FOR', explications, evt,
function(tr, crit) {
explications.forEach(function(e) {
addLineToFramedDisplay(display, e);
});
if (tr == 2) {
var msgRate = "C'est raté, " + perso.tokName + " est toujours agrippé" + eForFemale(perso.charId) + ".";
evt.personnage = perso;
evt.action = {
selected: [{
_id: perso.token.id
}],
playerId: playerId,
options: options
};
evt.type = 'libererAgrippe';
var pc = ficheAttributeAsInt(perso, 'PC', 0);
if (pc > 0) {
options.roll = options.roll || tr.roll;
msgRate += ' ' +
bouton("!cof-bouton-chance " + evt.id, "Chance", perso) +
" (reste " + pc + " PC)";
}
if (charAttributeAsBool(perso, 'runeDEnergie')) {
msgRate += ' ' + bouton("!cof-bouton-rune-energie " + evt.id, "Rune d'énergie", perso);
}
addLineToFramedDisplay(display, msgRate);
} else {
if (tr === 0)
addLineToFramedDisplay(display, "Réussi de justesse, " + perso.tokName + " se libère.");
else //tr == 1
addLineToFramedDisplay(display, "Réussi, " + perso.tokName + " se libère.");
toFront(perso.token);
if (attr.get('max')) setState(perso, 'immobilise', false, evt);
evt.deletedAttributes = evt.deletedAttributes || [];
evt.deletedAttributes.push(attr);
attr.remove();
attr = tokenAttribute(agrippant, 'agrippe');
attr.forEach(function(a) {
var ca = tokenOfIdName(a.get('current'));
if (ca && ca.token.id == perso.token.id) {
evt.deletedAttributes.push(a);
a.remove();
}
});
}
addEvent(evt);
sendChat('', endFramedDisplay(display));
});
});
});
}
//!cof-animer-cadavre lanceur cible
function animerCadavre(msg) {
var options = msg.options || parseOptions(msg);
if (options === undefined) return;
var cmd = options.cmd;
if (cmd === undefined || cmd.length < 3) {
error("cof-delivrance attend 2 arguments", msg.content);
return;
}
var lanceur = tokenOfId(cmd[1], cmd[1], options.pageId);
if (lanceur === undefined) {
error("Le premier argument de !cof-animer-cadavre n'est pas un token valide", msg.content);
return;
}
var cible = tokenOfId(cmd[2], cmd[2], options.pageId);
if (cible === undefined) {
error("Le deuxième argument de !cof-animer-cadavre n'est pas un token valide", msg.content);
return;
}
cible.tokName = cible.token.get('name');
if (!getState(cible, 'mort')) {
sendPlayer(msg, cible.tokName + " n'est pas mort" + eForFemale(cible.charId) + ".");
return;
}
if (attributeAsBool(cible, 'cadavreAnime')) {
sendPlayer(msg, cible.tokName + " a déjà été animé" + eForFemale(cible.charId) + ".");
return;
}
var evt = {
type: "Animer un cadvre"
};
if (limiteRessources(lanceur, options, 'animerUnCadavre', "animer un cadavre", evt)) return;
sendChar(lanceur.charId, 'réanime ' + cible.tokName);
setState(cible, 'mort', false, evt);
setTokenAttr(cible, 'cadavreAnime', true, evt, 'se relève');
addEvent(evt);
}
var niveauxEbriete = [
"sobre",
"pompette",
"bourré",
"ivre-mort",
"en coma éthylique"
];
function augmenteEbriete(personnage, evt, expliquer) {
personnage.tokName = personnage.tokName || personnage.token.get('name');
var n = attributeAsInt(personnage, 'niveauEbriete', 0) + 1;
if (n >= niveauxEbriete.length) {
expliquer(personnage.tokName + " est déjà en coma éthylique.");
return;
}
expliquer(personnage.tokName + " devient " + niveauxEbriete[n]);
setTokenAttr(personnage, 'niveauEbriete', n, evt);
}
function diminueEbriete(personnage, evt, expliquer) {
personnage.tokName = personnage.tokName || personnage.token.get('name');
var n = attributeAsInt(personnage, 'niveauEbriete', 0);
if (n < 1) return;
n--;
if (n >= niveauxEbriete.length) n = niveauxEbriete.length - 1;
expliquer(personnage.tokName + " redevient " + niveauxEbriete[n]);
setTokenAttr(personnage, 'niveauEbriete', n, evt);
}
function vapeursEthyliques(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
getSelected(msg, function(selected, playerId) {
var evt = {
type: 'Vapeurs éthyliques'
};
if (limiteRessources(options.lanceur, options, 'vapeursEthyliques', "lancer une fiole de vapeurs éthyliques", evt)) return;
var display = startFramedDisplay(playerId, 'Vapeurs éthyliques');
if (options.save) {
var title = " Jet de " + options.save.carac + " " + options.save.seuil;
title += " pour résister à l'alcool";
addLineToFramedDisplay(display, title);
title += options.msgPour;
}
initiative(selected, evt);
var count = selected.length;
var finalize = function() {
count--;
if (count > 0) return;
sendChat('', endFramedDisplay(display));
addEvent(evt);
};
var expliquer = function(m) {
addLineToFramedDisplay(display, m);
};
iterSelected(selected, function(perso) {
perso.tokName = perso.tokName || perso.token.get('name');
if (options.save) {
save(options.save, perso, expliquer, {
msgPour: " pour résister aux vapeurs éthyliques",
hideSaveTitle: true
}, evt,
function(succes, rollText) {
if (!succes) {
augmenteEbriete(perso, evt, expliquer);
setTokenAttr(perso, 'vapeursEthyliques', 0, evt, undefined, options.save.seuil);
}
finalize();
});
} else { //pas de save
augmenteEbriete(perso, evt, expliquer);
setTokenAttr(perso, 'vapeursEthyliques', 0, evt);
finalize();
}
}, finalize); //fin iterSelected
}, options); //fin getSelected
}
function desaouler(msg) {
getSelected(msg, function(selected, playerId) {
if (selected.length === 0) {
sendPlayer(msg, "Aucune sélection pour !cof-desaouler");
return;
}
var evt = {
type: 'desaoûler'
};
var expliquer = function(s) {
sendChat('', s);
};
iterSelected(selected, function(perso) {
diminueEbriete(perso, evt, expliquer);
});
addEvent(evt);
});
}
function boireAlcool(msg) {
var options = parseOptions(msg);
if (options === undefined) return;
getSelected(msg, function(selected, playerId) {
var evt = {
type: 'Boire alcool'
};
if (limiteRessources(options.lanceur, options, 'boireAlcool', "est affecté par l'alcool", evt)) return;
var display = startFramedDisplay(playerId, 'Alcool');
if (options.save) {
var title = " Jet de " + options.save.carac + " " + options.save.seuil;
title += " pour résister à l'alcool";
addLineToFramedDisplay(display, title);
title += options.msgPour;
}
var count = selected.length;
var finalize = function() {
count--;
if (count > 0) return;
sendChat('', endFramedDisplay(display));
addEvent(evt);
};
var expliquer = function(m) {
addLineToFramedDisplay(display, m);
};
iterSelected(selected, function(perso) {
perso.tokName = perso.tokName || perso.token.get('name');
if (options.save) {
save(options.save, perso, expliquer, {
hideSaveTitle: true
}, evt,
function(succes, rollText) {
if (!succes) {
augmenteEbriete(perso, evt, expliquer);
}
finalize();
});
} else { //pas de save
augmenteEbriete(perso, evt, expliquer);
finalize();
}
}, finalize); //fin iterSelected
}, options); //fin getSelected
}
function apiCommand(msg) {
msg.content = msg.content.replace(/\s+/g, ' '); //remove duplicate whites
var command = msg.content.split(" ", 1);
// First replace inline rolls by their values
replaceInline(msg);
var evt;
switch (command[0]) {
case "!cof-options":
setCofOptions(msg);
return;
case "!cof-jet":
jet(msg);
return;
case "!cof-resultat-jet":
resultatJet(msg);
return;
case "!cof-attack":
parseAttack(msg);
return;
case "!cof-undo":
undoEvent();
return;
case "!cof-hors-combat":
case "!cof-fin-combat":
sortirDuCombat();
return;
case "!cof-nuit": //deprecated
nuit(msg);
return;
case "!cof-jour": //deprecated
evt = {
type: "Nouveau jour"
};
jour(evt);
addEvent(evt);
return;
case "!cof-nouveau-jour":
nouveauJour(msg);
return;
case "!cof-recuperation":
recuperer(msg);
return;
case "!cof-recharger":
recharger(msg);
return;
case "!cof-chance": //deprecated
chance(msg);
return;
case "!cof-bouton-chance":
boutonChance(msg);
return;
case "!cof-bouton-rune-energie":
case "!cof-rune-energie":
runeEnergie(msg);
return;
case "!cof-rune-puissance":
runePuissance(msg);
return;
case "!cof-pousser-kiai":
kiai(msg);
return;
case "!cof-rune-protection":
runeProtection(msg);
return;
case "!cof-surprise":
surprise(msg);
return;
case "!cof-init":
if (msg.selected === undefined) {
error("Dans !cof-init : rien à faire, pas de token selectionné", msg);
return;
}
aura_token_on_turn = msg.content.indexOf('--aura') !== -1;
evt = {
type: "initiative"
};
initiative(msg.selected, evt);
addEvent(evt);
return;
case "!cof-turn-action":
case "!cof-liste-actions":
apiTurnAction(msg);
return;
case "!cof-attendre":
attendreInit(msg);
return;
case "!cof-statut":
statut(msg);
return;
case "!cof-armure-magique":
armureMagique(msg);
return;
case "!cof-buf-def":
bufDef(msg);
return;
case "!cof-remove-buf-def":
removeBufDef(msg);
return;
case "!cof-aoe": //deprecated
case "!cof-dmg":
dmgDirects(msg);
return;
case "!cof-set-state":
interfaceSetState(msg);
return;
case "!cof-save-state":
saveState(msg);
return;
case "!cof-degainer":
degainer(msg);
return;
case "!cof-echange-init":
echangeInit(msg);
return;
case "!cof-a-couvert":
aCouvert(msg);
return;
case "!cof-effet-temp":
effetTemporaire(msg);
return;
case "!cof-effet-combat":
effetCombat(msg);
return;
case "!cof-effet":
effetIndetermine(msg);
return;
case "!cof-fin-classe-effet":
finClasseDEffet(msg);
return;
case "!cof-attaque-magique":
attaqueMagique(msg);
return;
case "!cof-injonction":
injonction(msg);
return;
case "!cof-sommeil":
sommeil(msg);
return;
case "!cof-attaque-magique-contre-pv":
attaqueMagiqueContrePV(msg);
return;
case "!cof-transe-guerison":
transeGuerison(msg);
return;
case "!cof-soin":
soigner(msg);
return;
case "!cof-aoe-soin": //Deprecated
aoeSoin(msg);
return;
case "!cof-nature-nourriciere":
natureNourriciere(msg);
return;
case "!cof-ignorer-la-douleur":
ignorerLaDouleur(msg);
return;
case "!cof-fortifiant":
fortifiant(msg);
return;
case "!cof-intercepter":
intercepter(msg);
return;
case "!cof-interposer":
interposer(msg);
return;
case "!cof-esquive-fatale":
esquiveFatale(msg);
return;
case "!cof-exemplaire":
exemplaire(msg);
return;
case "!cof-lancer-sort":
lancerSort(msg);
return;
case "!cof-as":
emulerAs(msg);
return;
case "!cof-peur":
peur(msg);
return;
case "!cof-distribuer-baies":
distribuerBaies(msg);
return;
case "!cof-consommer-baie":
consommerBaie(msg);
return;
case "!cof-proteger-un-allie":
protegerUnAllie(msg);
return;
case "!cof-action-defensive":
actionDefensive(msg);
return;
case "!cof-strangulation":
strangulation(msg);
return;
case "!cof-ombre-mortelle":
ombreMortelle(msg);
return;
case "!cof-escalier":
escalier(msg);
return;
case "!cof-defaut-dans-la-cuirasse":
defautDansLaCuirasse(msg);
return;
case "!cof-posture-de-combat":
postureDeCombat(msg);
return;
case "!cof-mur-de-force":
murDeForce(msg);
return;
case "!cof-capitaine":
devientCapitaine(msg);
return;
case "!cof-tueur-fantasmagorique":
tueurFantasmagorique(msg);
return;
case "!cof-tour-de-force":
tourDeForce(msg);
return;
case "!cof-encaisser-un-coup":
encaisserUnCoup(msg);
return;
case "!cof-esquive-acrobatique":
esquiveAcrobatique(msg);
return;
case "!cof-absorber-au-bouclier":
absorberAuBouclier(msg);
return;
case "!cof-demarrer-statistiques":
if (stateCOF.statistiquesEnPause) {
stateCOF.statistiques = stateCOF.statistiquesEnPause;
delete stateCOF.statistiquesEnPause;
} else {
stateCOF.statistiques = {}; //remet aussi les statistiques à 0
}
return;
case "!cof-arreter-statistiques":
delete stateCOF.statistiques;
return;
case "!cof-pause-statistiques":
if (stateCOF.statistiques) {
stateCOF.statistiquesEnPause = stateCOF.statistiques;
delete stateCOF.statistiques;
} // sinon, ne pas écraser les statistiques déjà en pause
return;
case "!cof-statistiques":
displayStatistics(msg);
return;
case "!cof-destruction-des-morts-vivants":
destructionDesMortsVivants(msg);
return;
case "!cof-enduire-poison":
enduireDePoison(msg);
return;
case "!cof-consommables":
listeConsommables(msg);
return;
case "!cof-utilise-consommable": //Usage interne seulement
utiliseConsommable(msg, false);
return;
case "!cof-echange-consommables": //Usage interne seulement
utiliseConsommable(msg, true);
return;
case "!cof-provocation":
provocation(msg);
return;
case "!cof-en-selle":
enSelle(msg);
return;
case "!cof-creer-elixir": //usage interne seulement
creerElixir(msg);
return;
case "!cof-elixirs":
gestionElixir(msg);
return;
case "!cof-rage-du-berserk":
rageDuBerserk(msg);
return;
case "!cof-arme-secrete":
armeSecrete(msg);
return;
case "!cof-animer-arbre":
animerUnArbre(msg);
return;
case "!cof-delivrance":
case "!cof-guerir":
delivrance(msg);
return;
case "!cof-test-attaque-opposee":
testAttaqueOpposee(msg);
return;
case "!cof-manoeuvre":
manoeuvreRisquee(msg);
return;
case "!cof-appliquer-manoeuvre":
appliquerManoeuvre(msg);
return;
case "!cof-desarmer":
desarmer(msg);
return;
case "!cof-tempete-de-mana":
optionsDeTempeteDeMana(msg);
return;
case "!cof-deplacer-token":
deplacerToken(msg);
return;
case "!cof-permettre-deplacement":
permettreDeplacement(msg);
return;
case "!cof-tour-suivant":
tourSuivant(msg);
return;
case "!cof-multi-command":
multiCommand(msg);
return;
case "!cof-conjuration-de-predateur":
conjurationPredateur(msg);
return;
case "!cof-conjuration-armee":
conjurationArmee(msg);
return;
case "!cof-set-macros":
setGameMacros(msg);
return;
case "!cof-lumiere":
ajouteLumiere(msg);
return;
case "!cof-eteindre-lumiere":
eteindreLumieres(msg);
return;
case "!cof-torche":
switchTorche(msg);
return;
case "!cof-defi-samourai":
lancerDefiSamourai(msg);
return;
case "!cof-enveloppement":
enveloppement(msg);
return;
case "!cof-echapper-enveloppement":
echapperEnveloppement(msg);
return;
case "!cof-liberer-agrippe":
libererAgrippe(msg);
return;
case "!cof-animer-cadavre":
animerCadavre(msg);
return;
case "!cof-vapeurs-ethyliques":
vapeursEthyliques(msg);
return;
case "!cof-desaouler":
desaouler(msg);
return;
case "!cof-boire-alcool":
boireAlcool(msg);
return;
default:
return;
}
}
//Attributs possibles :
// dm : permet d'infliger des dm
// soins : soigne
// prejudiciable: est un effet préjudiciable, qui peut être enlevé par délivrance
// generic: admet un argument entre parenthèses
// seulementVivant: ne peut s'appliquer qu'aux créatures vivantes
var messageEffetTemp = {
sousTension: {
activation: "se charge d'énergie électrique",
actif: "est chargé d'énergie électrique",
fin: "n'est plus chargé d'énergie électrique",
dm: true
},
aCouvert: {
activation: "reste à couvert",
actif: "est à couvert",
fin: "n'est plas à couvert"
},
imageDecalee: {
activation: "décale légèrement son image",
actif: "a décalé son image",
fin: "apparaît à nouveau là où il se trouve"
},
chantDesHeros: {
activation: "écoute le chant du barde",
actif: "est inspiré par le Chant des Héros",
fin: "n'est plus inspiré par le Chant des Héros"
},
benediction: {
activation: "est touché par la bénédiction",
actif: "est béni",
fin: "l'effet de la bénédiction s'estompe"
},
peauDEcorce: {
activation: "donne à sa peau la consistance de l'écorce",
actif: "a la peau dure comme l'écorce",
fin: "retrouve une peau normale"
},
rayonAffaiblissant: {
activation: "est touché par un rayon affaiblissant",
actif: "est sous l'effet d'un rayon affaiblissant",
fin: "n'est plus affaibli",
prejudiciable: true
},
peur: {
activation: "prend peur",
actif: "est dominé par sa peur",
fin: "retrouve du courage",
prejudiciable: true
},
peurEtourdi: {
activation: "prend peur: il peut fuir ou rester recroquevillé",
actif: "est paralysé par la peur",
fin: "retrouve du courage et peut à nouveau agir",
prejudiciable: true
},
aveugleTemp: {
activation: "n'y voit plus rien !",
actif: "", //Déjà affiché avec l'état aveugle
fin: "retrouve la vue",
prejudiciable: true
},
ralentiTemp: {
activation: "est ralenti : une seule action, pas d'action limitée",
actif: "", //Déjà affiché avec l'état ralenti
fin: "n'est plus ralenti",
prejudiciable: true
},
paralyseTemp: {
activation: "est paralysé : aucune action ni déplacement possible",
actif: "", //Déjà affiché avec l'état ralenti
fin: "n'est plus paralysé",
prejudiciable: true
},
etourdiTemp: {
activation: "est étourdi : aucune action et -5 en DEF",
actif: "", //Déjà affiché avec l'état ralenti
fin: "n'est plus étourdi",
prejudiciable: true
},
affaibliTemp: {
activation: "se sent faible",
actif: "", //Déjà affiché avec l'état aveugle
fin: "se sent moins faible",
prejudiciable: true
},
aveugleManoeuvre: {
activation: "est aveuglé par la manoeuvre",
actif: "a du mal à voir où sont ses adversaires",
fin: "retrouve une vision normale",
prejudiciable: true
},
bloqueManoeuvre: {
activation: "est bloqué par la manoeuvre",
actif: "est bloqué et ne peut pas se déplacer",
fin: "peut à nouveau se déplacer",
prejudiciable: true
},
diversionManoeuvre: {
activation: "est déconcentré",
actif: "a été perturbé par une diversion",
fin: "se reconcentre sur le combat",
prejudiciable: true
},
menaceManoeuvre: {
activation: "est menacé",
actif: "a été menacée, risque de plus de DM",
fin: "n'est plus sous la menace",
prejudiciable: true,
generic: true
},
tenuADistanceManoeuvre: {
activation: "est tenu à distance",
actif: "est tenu à distance de son adversaire, il ne peut pas l'attaquer",
fin: "peut à nouveau attaquer son adversaire",
prejudiciable: true,
generic: true
},
epeeDansante: {
activation: "fait apparaître une lame d'énergie lumineuse",
actif: "contrôle une lame d'énergie lumineuse",
fin: "La lame d'énergie lumineuse disparaît",
dm: true
},
putrefaction: {
activation: "vient de contracter une sorte de lèpre fulgurante",
actif: "est en pleine putréfaction",
fin: "La putréfaction s'arrête.",
prejudiciable: true,
dm: true
},
forgeron: {
activation: "enflamme son arme",
actif: "a une arme en feu",
fin: "L'arme n'est plus enflammée.",
dm: true,
generic: true
},
armeEnflammee: {
activation: "voit son arme prendre feu",
actif: "a une arme enflammée",
fin: "L'arme n'est plus enflammée.",
dm: true,
generic: true
},
armesEnflammees: {
activation: "voit ses armes prendre feu",
actif: "a des armes enflammées",
fin: "Les armes ne sont plus enflammées.",
dm: true,
},
dotGen: {
activation: "subit un effet",
actif: "subit régulièrement des dégâts",
fin: "ne subit plus ces effets de dégâts",
dm: true,
generic: true
},
rechargeGen: {
activation: "doit maintenant attendre un peu avant de pouvoir le refaire",
actif: "attends avant de pouvoir refaire une attaque",
fin: "a récupéré",
generic: true
},
dmgArme1d6: {
activation: "enduit son arme d'une huile magique",
actif: "a une arme plus puissante",
fin: "L'arme retrouve sa puissance normale",
dm: true,
generic: true
},
flou: {
activation: "devient flou",
actif: "apparaît flou",
fin: "redevient net"
},
agrandissement: {
activation: "se met à grandir",
actif: "est vraiment très grand",
fin: "retrouve sa taille normale"
},
formeGazeuse: {
activation: "semble perdre de la consistance",
actif: "est en forme gazeuse",
fin: "retrouve sa consistance normale"
},
intangible: {
activation: "devient translucide",
actif: "est intangible",
fin: "redevient solide"
},
strangulation: {
activation: "commence à étouffer",
actif: "est étranglé",
fin: "respire enfin",
prejudiciable: true,
seulementVivant: true,
dm: true
},
ombreMortelle: {
activation: "voit son ombre s'animer et l'attaquer !",
actif: "est une ombre animée",
fin: "retrouve une ombre normale",
dm: true
},
dedoublement: {
activation: "voit un double translucide sortir de lui",
actif: "est un double translucide",
fin: "le double disparaît",
dm: true
},
zoneDeSilence: {
activation: "n'entend plus rien",
actif: "est totalement sourd",
fin: "peut à nouveau entendre"
},
danseIrresistible: {
activation: "se met à danser",
actif: "danse malgré lui",
fin: "s'arrête de danser",
prejudiciable: true
},
confusion: {
activation: "ne sait plus très bien ce qu'il fait là",
actif: "est en pleine confusion",
fin: "retrouve ses esprits",
prejudiciable: true
},
murDeForce: {
activation: "fait apparaître un mur de force",
actif: "en entouré d'un mur de force",
fin: "voit son mur de force disparaître"
},
asphyxie: {
activation: "commence à manquer d'air",
actif: "étouffe",
fin: "peut à nouveau respirer",
prejudiciable: true,
seulementVivant: true,
statusMarker: 'overdrive',
dm: true
},
forceDeGeant: {
activation: "devient plus fort",
actif: "a une force de géant",
fin: "retrouve sa force normale"
},
saignementsSang: {
activation: "commence à saigner du nez, des oreilles et des yeux",
actif: "saigne de tous les orifices du visage",
fin: "ne saigne plus",
prejudiciable: true,
statusMarker: 'red',
dm: true
},
encaisserUnCoup: {
activation: "se place de façon à dévier un coup sur son armure",
actif: "est placé de façon à dévier un coup",
fin: "n'est plus en position pour encaisser un coup"
},
absorberUnCoup: {
activation: "se prépare à absorber un coup avec son bouclier",
actif: "est prêt à absorber un coup avec son bouclier",
fin: "n'est plus en position de prendre le prochain coup sur son bouclier"
},
absorberUnSort: {
activation: "se prépare à absorber un sort avec son bouclier",
actif: "est prêt à absorber un sort avec son bouclier",
fin: "n'est plus en position de se protéger d'un sort avec son bouclier"
},
nueeDInsectes: {
activation: "est attaqué par une nuée d'insectes",
actif: "est entouré d'une nuée d'insectes",
fin: "est enfin débarassé des insectes",
prejudiciable: true,
dm: true
},
prisonVegetale: {
activation: "voit des plantes pousser et s'enrouler autour de ses jambes",
actif: "est bloqué par des plantes",
fin: "se libère des plantes",
prejudiciable: true
},
protectionContreLesElements: {
activation: "lance un sort de protection contre les éléments",
actif: "est protégé contre les éléments",
fin: "n'est plus protégé contre les éléments"
},
masqueMortuaire: {
activation: "prend l'apparence de la mort",
actif: "semble mort et animé",
fin: "retrouve une apparence de vivant"
},
armeBrulante: {
activation: "sent son arme lui chauffer la main",
actif: "se brûle la main sur son arme",
fin: "sent son arme refroidir",
dm: true
},
armureBrulante: {
activation: "sent son armure chauffer",
actif: "brûle dans son armure",
fin: "sent son armure refroidir",
dm: true
},
masqueDuPredateur: {
activation: "prend les traits d'un prédateur",
actif: "a les traits d'un prédateur",
fin: "redevient normal"
},
aspectDeLaSuccube: {
activation: "acquiert une beauté fascinante",
actif: "est d'une beauté fascinante",
fin: "retrouve sa beauté habituelle"
},
aspectDuDemon: {
activation: "prend l’apparence d’un démon",
actif: "a l’apparence d’un démon",
fin: "retrouve son apparence habituelle"
},
sangMordant: {
activation: "transforme son sang",
actif: "a du sang acide",
fin: "retrouve un sang normal"
},
armeSecreteBarde: {
activation: "est déstabilisé",
actif: "est déstabilisé par une action de charme",
fin: "retrouve ses esprits",
prejudiciable: true
},
regeneration: {
activation: "commence à se régénérer",
actif: "se régénère",
fin: "a fini de se régénérer",
soins: true
},
arbreAnime: {
activation: "commence à bouger",
actif: "est un arbre animé",
fin: "redevient un arbre ordinaire"
},
magnetisme: {
activation: "contrôle le magnétisme",
actif: "contrôle le magnétisme",
fin: "relache son contrôle du magnétisme"
},
hate: {
activation: "voit son métabolisme s'accélérer",
actif: "peut faire une action de plus par tour",
fin: "retrouve un métabolisme normal (plus d'action supplémentaire)"
},
ailesCelestes: {
activation: "sent des ailes célestes lui pousser dans le dos",
actif: "possède des ailes célestes",
fin: "n'a plus d'aile céleste. Espérons qu'il était au sol..."
},
sanctuaire: {
activation: "lance un sort de sanctuaire",
actif: "est protégé par un sanctuaire",
fin: "n'est plus protégé par le sanctuaire"
},
rechargeSouffle: {
activation: "doit maintenant attendre un peu avant de pouvoir le refaire",
actif: "attends avant de pouvoir refaire un souffle",
fin: "a récupéré"
},
paralysieRoublard: {
activation: "est paralysé par la douleur",
actif: "ne peut pas attaquer ni se déplacer",
fin: "peut à nouveau attaquer et se déplacer",
prejudiciable: true,
seulementVivant: true
},
mutationOffensive: {
activation: "échange une partie de son corps avec celle d'une créature monstrueuse",
actif: "possède un appendice monstrueux",
fin: "retrouve un corps normal"
},
formeDArbre: {
activation: "se transorme en arbre",
actif: "est transformé en arbre",
fin: "retrouve sa forme normale"
},
statueDeBois: {
activation: "se transforme en statue de bois",
actif: "est transformé en statue de bois",
fin: "retrouve sa forme normale",
prejudiciable: true
},
clignotement: {
activation: "disparaît, puis réapparaît",
actif: "clignote",
fin: "ne disparaît plus"
},
agitAZeroPV: {
activation: "continue à agir malgré les blessures",
actif: "devrait être à terre",
fin: "subit l'effet de ses blessures"
},
predateurConjure: {
activation: "apparaît depuis un autre plan",
actif: "est un prédateur conjuré",
fin: "disparaît",
dm: true
},
champDeProtection: {
activation: "devient protégé par un champ télékinétique",
actif: "est protégé par un champ télékinétique",
fin: "n'est plus sous l'effet d'un champ de protection",
},
attaqueArmeeConjuree: {
activation: "se bat contre une armée conjurée",
actif: "se bat contre une armée conjurée",
fin: "ne se bat plus contre l'armée conjurée"
},
rechargeDuKiai: {
activation: "pousse un kiai",
actif: "ne peut pas encore pousser un autre kiai",
fin: "peut pousser un autre kiai"
},
memePasMalBonus: {
activation: "enrage suite au coup critique",
actif: "a subit un coup critique",
fin: "ne bénéficie plus des effets de même pas mal"
},
attaqueRisquee: {
activation: "fait une attaque risquée",
actif: "s'est mis en danger par une attaque risquée",
fin: "retrouve une position moins risquée",
},
};
function buildPatternEffets(listeEffets, postfix) {
if (postfix && postfix.length === 0) postfix = undefined;
var expression = "(";
expression = _.reduce(listeEffets, function(reg, msg, effet) {
var res = reg;
if (res !== "(") res += "|";
res += "^" + effet;
if (msg.generic) res += "\\([^)]*\\)";
res += "(";
if (postfix) {
postfix.forEach(function(p, i) {
if (i) res += "|";
res += p + "$|" + p + "_";
});
} else res += "$|_";
res += ")";
return res;
}, expression);
expression += ")";
return new RegExp(expression);
}
var patternEffetsTemp = buildPatternEffets(messageEffetTemp);
function estEffetTemp(name) {
return (patternEffetsTemp.test(name));
}
var patternAttributEffetsTemp = buildPatternEffets(messageEffetTemp, ["Puissant", "Valeur", "SaveParTour", "TempeteDeManaIntense"]);
function estAttributEffetTemp(name) {
return (patternAttributEffetsTemp.test(name));
}
//On sait déjà que le nom a passé le test estEffetTemp
function effetTempOfAttribute(attr) {
var ef = attr.get('name');
if (ef === undefined || messageEffetTemp[ef]) return ef;
//D'abord on enlève le nom du token
var pu = ef.indexOf('_');
if (pu > 0) {
ef = ef.substring(0, pu);
if (messageEffetTemp[ef]) return ef;
}
//Ensuite on enlève les parties entre parenthèse pour les effets génériques
pu = ef.indexOf('(');
if (pu > 0) {
ef = ef.substring(0, pu);
if (messageEffetTemp[ef]) return ef;
}
error("Impossible de déterminer l'effet correspondant à " + ef, attr);
}
function messageOfEffetTemp(effetC) {
var res = messageEffetTemp[effetC];
if (res) return res;
var p = effetC.indexOf('(');
if (p > 0) {
var ef = effetC.substring(0, p);
res = messageEffetTemp[ef];
return res;
}
error("Effet temporaire non trouvé", effetC);
}
var messageEffetCombat = {
armureMagique: {
activation: "est entouré d'un halo magique",
actif: "est protégé par une armure magique",
fin: "n'est plus entouré d'un halo magique"
},
armureDuMage: {
activation: "fait apparaître un nuage magique argenté qui le protège",
actif: "est entouré d'une armure du mage",
fin: "n'a plus son armure du mage"
},
armeDArgent: {
activation: "crée une arme d'argent et de lumière",
actif: "possède une arme d'argent et de lumière",
fin: "ne possède plus d'arme d'argent et de lumière",
dm: true
},
criDeGuerre: {
activation: "pousse son cri de guerre",
actif: "a effrayé ses adversaires",
fin: ""
},
criDuPredateur: {
activation: "pousse un hurlement effrayant",
actif: "a libéré son âme de prédateur",
fin: ""
},
protectionContreLeMal: {
activation: "reçoit une bénédiction de protection contre le mal",
actif: "est protégé contre le mal",
fin: "n'est plus protégé contre le mal"
},
rageDuBerserk: {
activation: "entre dans une rage berserk",
actif: "est dans une rage berserk",
fin: "retrouve son calme"
},
enragé: {
activation: "devient enragé",
actif: "est enragé",
fin: "retrouve son calme"
},
bonusInitEmbuscade: { //Effet interne pour la capacité Surveillance
activation: "a un temps d'avance en cas d'embuscade",
actif: "a un temps d'avance",
fin: ""
},
putrefactionOutreTombe: {
activation: "sent ses chairs pourrir",
actif: "subit le contrecoup d'une putréfaction",
fin: "se remet de la putréfaction",
prejudiciable: true,
dm: true
},
bonusInitVariable: {
activation: "entre en combat",
actif: "est en combat",
fin: ''
},
defiSamourai: {
activation: "lance un défi",
actif: "a lancé un défi",
fin: ''
},
agrippe: {
activation: "agrippe sa cible",
actif: "agrippe sa cible",
fin: "lache sa cible"
},
estAgrippePar: {
activation: "est agrippé",
actif: "est agrippé",
fin: "se libère"
}
};
var patternEffetsCombat = buildPatternEffets(messageEffetCombat);
function estEffetCombat(name) {
return (patternEffetsCombat.test(name));
}
var patternAttributEffetsCombat = buildPatternEffets(messageEffetCombat, ["Puissant", "Valeur", "SaveParTour", "TempeteDeManaIntense"]);
function estAttributEffetCombat(name) {
return (patternAttributEffetsCombat.test(name));
}
function effetCombatOfAttribute(attr) {
var ef = attr.get('name');
if (ef === undefined || messageEffetCombat[ef]) return ef;
//D'abord on enlève le nom du token
var pu = ef.indexOf('_');
if (pu > 0) {
ef = ef.substring(0, pu);
if (messageEffetCombat[ef]) return ef;
}
error("Impossible de déterminer l'effet correspondant à " + ef, attr);
}
var messageEffetIndetermine = {
aCheval: { //deprecated, mieux vaut utiliser la commande !cof-en-selle
activation: "monte sur sa monture",
actif: "est sur sa monture",
fin: "descend de sa monture"
},
marcheSylvestre: {
activation: "se deplace maintenant en terrain difficile",
actif: "profite du terrain difficile",
fin: "est maintenant en terrain normal"
},
mutationCuirasse: {
activation: "endurcit sa peau",
actif: "a la peau recouverte d'une cuirasse",
fin: "retrouve une peau normale"
},
mutationEcaillesRouges: {
activation: "recouvre sa peau d'écailles rouges",
actif: "a la peau recouverte d'écailles rouges",
fin: "retrouve une peau normale"
},
mutationFourrureViolette: {
activation: "se fait pousser une fourrure violette",
actif: "a la peau recouverte d'une fourrure violette",
fin: "retrouve une peau normale"
},
mutationOuies: {
activation: "se fait pousser des ouïes",
actif: "possède des ouïes",
fin: "n'a plus d'ouïes"
},
mutationSangNoir: {
activation: "prend un teint plus sombre",
actif: "a le sang noir",
fin: "retrouve un sang normal"
},
mutationMusclesHypertrophies: {
activation: "devient plus musclé",
actif: "a les muscles hypertrophiés",
fin: "retrouve des muscles normaux",
},
mutationSilhouetteFiliforme: {
activation: "devient plus fin",
actif: "a une silhouette filiforme",
fin: "retrouve une silhouette normale",
},
mutationSilhouetteMassive: {
activation: "devient plus massif",
actif: "a une silhouette massive",
fin: "retrouve une silhouette normale",
},
sixiemeSens: {
activation: "fait un rituel de divination",
actif: "sait un peu à l'avance ce qu'il va se passer",
fin: "l'effet du rituel de divination prend fin",
},
};
var patternEffetsIndetermine = buildPatternEffets(messageEffetIndetermine);
function estEffetIndetermine(name) {
return (patternEffetsIndetermine.test(name));
}
function effetIndetermineOfAttribute(attr) {
var ef = attr.get('name');
if (ef === undefined || messageEffetIndetermine[ef]) return ef;
//D'abord on enlève le nom du token
var pu = ef.indexOf('_');
if (pu > 0) {
ef = ef.substring(0, pu);
if (messageEffetIndetermine[ef]) return ef;
}
error("Impossible de déterminer l'effet correspondant à " + ef, attr);
}
//L'argument effet doit être le nom complet, pas la base
//evt.deletedAttributes doit être défini
function enleverEffetAttribut(charId, effet, attrName, attribut, evt) {
var nameWithSave = effet + attribut + attrName.substr(effet.length);
findObjs({
_type: 'attribute',
_characterid: charId,
name: nameWithSave
}).
forEach(function(attrS) {
evt.deletedAttributes.push(attrS);
attrS.remove();
});
}
function effetComplet(effet, attrName) {
if (effet == attrName) return effet;
var p = attrName.indexOf('(', effet.length - 1);
if (p > 0) {
p = attrName.indexOf(')', p);
if (p > 0) return attrName.substring(0, p + 1);
}
return effet;
}
function finDEffet(attr, effet, attrName, charId, evt, options) { //L'effet arrive en fin de vie, doit être supprimé
options = options || {};
evt.deletedAttributes = evt.deletedAttributes || [];
var res;
var newInit = [];
var efComplet = effetComplet(effet, attrName);
//Si on a un attrSave, alors on a déjà imprimé le message de fin d'effet
if (options.attrSave) { //on a un attribut associé à supprimer)
evt.deletedAttributes.push(options.attrSave);
options.attrSave.remove();
} else if (options.gardeAutresAttributs === undefined) { //On cherche si il y en a un
enleverEffetAttribut(charId, efComplet, attrName, 'SaveParTour', evt);
}
var mEffet = messageEffetTemp[effet];
if (mEffet.statusMarker) {
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
affectToken(token, 'statusmarkers', token.get('statusmarkers'), evt);
token.set('status_' + mEffet.statusMarker, false);
}, {
tousLesTokens: true
});
}
switch (effet) {
case 'agrandissement': //redonner sa taille normale
var character = getObj('character', charId);
if (character === undefined) {
error("Personnage introuvable");
return;
}
character.get('defaulttoken', function(normalToken) {
normalToken = JSON.parse(normalToken);
var largeWidth = normalToken.width + normalToken.width / 2;
var largeHeight = normalToken.height + normalToken.height / 2;
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
var width = token.get('width');
var height = token.get('height');
affectToken(token, 'width', width, evt);
token.set('width', normalToken.width);
affectToken(token, 'height', height, evt);
token.set('height', normalToken.height);
}, {
filterAffected: function(token) {
if (token.get('width') == largeWidth) return true;
if (token.get('height') == largeHeight) return true;
return false;
}
});
});
break;
case 'aveugleTemp':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'aveugle', false, evt);
}, {
tousLesTokens: true
});
break;
case 'ralentiTemp':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'ralenti', false, evt);
}, {
tousLesTokens: true
});
break;
case 'paralyseTemp':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'paralyse', false, evt);
}, {
tousLesTokens: true
});
break;
case 'etourdiTemp':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'etourdi', false, evt);
}, {
tousLesTokens: true
});
break;
case 'affaibliTemp':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'affaibli', false, evt);
}, {
tousLesTokens: true
});
break;
case 'peur':
case 'peurEtourdi':
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
setState({
token: token,
charId: charId
}, 'apeure', false, evt);
}, {
tousLesTokens: true
});
break;
case 'ombreMortelle':
case 'dedoublement':
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
token.remove();
});
break;
case 'murDeForce':
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
var attrM = tokenAttribute({
charId: charId,
token: token
}, 'murDeForceId');
if (attrM.length === 0) return;
var imageMur = getObj('graphic', attrM[0].get('current'));
if (imageMur) {
imageMur.remove();
}
attrM[0].remove();
});
break;
case 'regeneration': //faire les soins restants
var toursRestant = attr.get('current');
if (toursRestant == 'tourFinal' || isNaN(toursRestant)) break;
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
var perso = {
token: token,
charId: charId
};
var regen = getValeurOfEffet(perso, 'regeneration', 3);
var soins = regen * (toursRestant + attributeAsInt(perso, 'regenerationTempeteDeManaIntense', 0));
soigneToken(perso, soins, evt,
function(s) {
options.print = function(m) {}; //Pour ne pas afficher le message final.
var tempsEffectif = Math.ceil(s / regen);
sendChar(charId, "récupère encore " + s + " PV en " + tempsEffectif + " tours.");
});
});
break;
case 'predateurConjure':
case 'arbreAnime': //effacer le personnage
//On efface d'abord les attributs et les abilities
var charAttributes = findObjs({
_type: 'attribute',
_characterid: charId
});
charAttributes.forEach(
function(otherAttr) {
if (otherAttr.id != attr.id) otherAttr.remove();
}
);
var charAbilities = findObjs({
_type: 'ability',
_characterid: charId
});
charAbilities.forEach(
function(ab) {
ab.remove();
}
);
if (effet == 'arbreAnime') {
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
removeFromTurnTracker(token.id, evt);
setToken(token, 'bar1_link', '', evt);
setToken(token, 'bar1_value', '', evt);
setToken(token, 'bar1_max', '', evt);
setToken(token, 'showplayers_bar1', false, evt);
setToken(token, 'represents', '', evt);
setToken(token, 'showname', false, evt);
setToken(token, 'showplayers_name', false, evt);
setToken(token, 'name', '', evt);
});
} else if (effet == 'predateurConjure') {
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
token.remove();
});
}
attr.remove();
if (options.print) options.print(mEffet.fin);
else sendChar(charId, 'disparaît');
var arbreChar = getObj('character', charId);
if (arbreChar) {
evt.deletedCharacters = evt.deletedCharacters || [];
evt.deletedCharacters.push({
id: charId,
name: arbreChar.get('name'),
avatar: arbreChar.get('avatar'),
attributes: charAttributes,
abilities: charAbilities
});
arbreChar.remove();
}
return; //Pas besoin de faire le reste, car plus de perso
case 'formeDArbre':
var tokenChange = charIdAttributeAsBool(charId, 'changementDeToken');
var iterTokOptions = {};
if (tokenChange) {
removeTokenAttr({
charId: charId
}, 'changementDeToken', evt);
iterTokOptions.tousLesTokens = true;
}
iterTokensOfAttribute(charId, options.pageId, effet, attrName,
function(token) {
var perso = {
token: token,
charId: charId
};
if (tokenChange) {
var tokenMJ =
findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: token.get('pageid'),
layer: 'gmlayer',
represents: charId,
name: token.get('name')
});
if (tokenMJ.length === 0) return;
var nouveauToken = tokenMJ[0];
setToken(nouveauToken, 'layer', 'objects', evt);
setToken(nouveauToken, 'left', token.get('left'), evt);
setToken(nouveauToken, 'top', token.get('top'), evt);
setToken(nouveauToken, 'width', token.get('width'), evt);
setToken(nouveauToken, 'height', token.get('height'), evt);
setToken(nouveauToken, 'rotation', token.get('rotation'), evt);
setToken(nouveauToken, 'bar2_value', token.get('bar2_value'), evt);
setToken(nouveauToken, 'aura1_radius', token.get('aura1_radius'), evt);
setToken(nouveauToken, 'aura1_color', token.get('aura1_color'), evt);
setToken(nouveauToken, 'aura1_square', token.get('aura1_square'), evt);
setToken(nouveauToken, 'showplayers_aura1', token.get('showplayers_aura1'), evt);
setToken(nouveauToken, 'aura2_radius', token.get('aura2_radius'), evt);
setToken(nouveauToken, 'aura2_color', token.get('aura2_color'), evt);
setToken(nouveauToken, 'aura2_square', token.get('aura2_square'), evt);
setToken(nouveauToken, 'showplayers_aura2', token.get('showplayers_aura2'), evt);
setToken(nouveauToken, 'statusmarkers', token.get('statusmarkers'), evt);
setToken(nouveauToken, 'light_angle', token.get('light_angle'), evt);
if (stateCOF.combat) {
replaceInTurnTracker(token.id, nouveauToken.id, evt);
}
res = res || {};
res.oldTokenId = token.id;
res.newTokenId = nouveauToken.id;
res.newToken = nouveauToken;
token.remove();
token = nouveauToken;
perso.token = nouveauToken;
}
var apv = tokenAttribute(perso, 'anciensPV');
if (apv.length > 0) {
updateCurrentBar(token, 1, apv[0].get('current'), evt, apv[0].get('max'));
removeTokenAttr(perso, 'anciensPV', evt);
if (stateCOF.combat) {
newInit.push({
_id: token.id
});
}
}
},
iterTokOptions);
break;
case 'agitAZeroPV':
iterTokensOfAttribute(charId, options.pageId, effet, attrName, function(token) {
var pv = token.get('bar1_value');
if (pv == 0) { //jshint ignore:line
mort({
charId: charId,
token: token
}, undefined, evt);
}
});
break;
default:
}
if (options.attrSave === undefined && charId) {
var estMort = true;
iterTokensOfAttribute(charId, options.pageId, efComplet, attrName, function(token) {
estMort = estMort && getState({
charId: charId,
token: token
}, 'mort');
});
if (!estMort) {
if (options.print) options.print(mEffet.fin);
else {
if (attrName == efComplet)
sendChar(charId, mEffet.fin);
else {
var tokenName = attrName.substring(attrName.indexOf('_') + 1);
sendChat('', tokenName + ' ' + mEffet.fin);
}
}
}
}
if (options.gardeAutresAttributs === undefined && charId) {
enleverEffetAttribut(charId, efComplet, attrName, 'Puissant', evt);
enleverEffetAttribut(charId, efComplet, attrName, 'Valeur', evt);
enleverEffetAttribut(charId, efComplet, attrName, 'TempeteDeManaIntense', evt);
}
evt.deletedAttributes.push(attr);
attr.remove();
if (newInit.length > 0) initiative(newInit, evt, true);
return res;
}
function finDEffetDeNom(perso, effet, evt, options) { //Supprime l'effet si présent
var attrs = tokenAttribute(perso, effet);
if (attrs.length === 0) return;
options = options || {};
options.pageId = options.pageId || perso.token.get('pageid');
finDEffet(attrs[0], effet, attrs[0].get('name'), perso.charId, evt, options);
}
//asynchrone
// effet est le nom complet de l'effet
function degatsParTour(charId, pageId, effet, attrName, dmg, type, msg, evt, options, callback) {
options = options || {};
if (msg) msg += '. ' + onGenre(charId, 'Il', 'Elle');
else msg = '';
var count = -1;
iterTokensOfAttribute(charId, pageId, effet, attrName,
function(token, total) {
if (count < 0) count = total;
var perso = {
token: token,
charId: charId
};
var dmgExpr = dmg;
var tdmi = attributeAsInt(perso, effet + "TempeteDeManaIntense", 0);
if (dmg.de) {
if (tdmi) {
dmgExpr = (tdmi + dmg.nbDe) + 'd' + dmg.de;
removeTokenAttr(perso, effet + "TempeteDeManaIntense", evt);
} else dmgExpr = dmg.nbDe + 'd' + dmg.de;
} else if (dmg.cst) {
if (tdmi) {
dmgExpr = dmg.cst * (1 + tdmi);
removeTokenAttr(perso, effet + "TempeteDeManaIntense", evt);
} else dmgExpr = dmg.cst;
} else if (options.dotGen) {
//alors dmg = '' et type = ''
var valAttr = tokenAttribute(perso, effet + 'Valeur');
if (valAttr.length === 0) {
//Par défaut, 1d6 DM normaux
dmgExpr = "1d6";
type = 'normal';
} else {
dmgExpr = valAttr[0].get('current');
type = valAttr[0].get('max');
if (type === '') type = 'normal';
}
}
sendChat('', "[[" + dmgExpr + "]]", function(res) {
var rolls = res[0];
var dmgRoll = rolls.inlinerolls[0];
var r = {
total: dmgRoll.results.total,
type: type,
display: buildinline(dmgRoll, type)
};
dealDamage(perso, r, [], evt, false, options, undefined,
function(dmgDisplay, dmg) {
if (dmg > 0) {
if (effet == attrName) {
sendChar(charId, msg + " subit " + dmgDisplay + " DM");
} else {
var tokenName = attrName.substring(attrName.indexOf('_') + 1);
sendChat('', tokenName + ' ' + msg + " subit " + dmgDisplay + " DM");
}
}
count--;
if (count === 0) callback();
});
}); //fin sendChat du jet de dé
}); //fin iterTokensOfAttribute
}
//asynchrone
function soigneParTour(charId, pageId, effet, attrName, soinsExpr, msg, evt, options, callback) {
options = options || {};
msg = msg || '';
var count = -1;
iterTokensOfAttribute(charId, pageId, effet, attrName,
function(token, total) {
if (count < 0) count = total;
var perso = {
token: token,
charId: charId
};
var tdmi = attributeAsInt(perso, effet + "TempeteDeManaIntense", 0);
if (tdmi) {
soinsExpr = "(" + soinsExpr + ")*" + (1 + tdmi);
removeTokenAttr(perso, effet + "TempeteDeManaIntense", evt);
}
var localSoinsExpr = soinsExpr;
if (options.valeur) {
var attrsVal = tokenAttribute(perso, options.valeur);
if (attrsVal.length > 0) localSoinsExpr = attrsVal[0].get('current');
}
sendChat('', "[[" + localSoinsExpr + "]]", function(res) {
var rolls = res[0];
var soinRoll = rolls.inlinerolls[0];
var soins = soinRoll.results.total;
var displaySoins = buildinline(soinRoll, 'normal', true);
soigneToken(perso, soins, evt,
function(s) {
if (s < soins) sendChar(charId, "récupère tous ses PV.");
else sendChar(charId, "récupère " + displaySoins + " PV.");
count--;
if (count === 0) callback();
},
function() {
count--;
if (count === 0) callback();
});
}); //fin sendChat du jet de dé
}); //fin iterTokensOfAttribute
}
function nextTurn(cmp) {
if (!cmp.get('initiativepage')) return;
var turnOrder = cmp.get('turnorder');
var pageId = stateCOF.combat_pageid;
if (pageId === undefined) pageId = cmp.get('playerpageid');
if (turnOrder === '') return; // nothing in the turn order
turnOrder = JSON.parse(turnOrder);
if (turnOrder.length < 1) return; // Juste le compteur de tour
var evt = {
type: 'Personnage suivant',
attributes: [],
deletedAttributes: []
};
var active = turnOrder[0];
var lastHead = turnOrder.pop();
turnOrder.unshift(lastHead);
evt.turnorder = JSON.stringify(turnOrder);
var attrs = findObjs({
_type: 'attribute'
});
// Si on a changé d'initiative, alors diminue les effets temporaires
var init = parseInt(active.pr);
if (active.id == "-1" && active.custom == "Tour") init = 0;
var count = 0; // pour l'aspect asynchrone des effets temporaires
if (stateCOF.init > init) {
var attrsTemp = attrs.filter(function(obj) {
if (!estEffetTemp(obj.get('name'))) return false;
var obji = obj.get('max');
return (init < obji && obji <= stateCOF.init);
});
evt.init = stateCOF.init;
stateCOF.init = init;
// Boucle sur les effets temps peut être asynchrone à cause des DM
count = attrsTemp.length;
attrsTemp.forEach(function(attr) {
var charId = attr.get('characterid');
var effet = effetTempOfAttribute(attr);
if (effet === undefined) {
//erreur, on stoppe tout
log(attr);
count--;
return;
}
var attrName = attr.get('name');
var v = attr.get('current');
if (v == 'tourFinal') { //L'effet arrive en fin de vie, doit être supprimé
var effetFinal = finDEffet(attr, effet, attrName, charId, evt, {
pageId: pageId
});
if (effetFinal && effetFinal.oldTokenId == active.id)
active.id = effetFinal.newTokenId;
count--;
} else { //Effet encore actif
evt.attributes.push({
attribute: attr,
current: v
});
if (v > 1) attr.set('current', v - 1);
else attr.set('current', 'tourFinal');
switch (effet) { //rien après le switch, donc on sort par un return
case 'putrefaction': //prend 1d6 DM
degatsParTour(charId, pageId, effet, attrName, {
nbDe: 1,
de: 6
}, 'maladie',
"pourrit", evt, {
magique: true
},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'asphyxie': //prend 1d6 DM
degatsParTour(charId, pageId, effet, attrName, {
nbDe: 1,
de: 6
}, 'normal',
"ne peut plus respirer", evt, {
asphyxie: true
},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'saignementsSang': //prend 1d6 DM
if (charIdAttributeAsBool(charId, 'immuniteSaignement')) {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
return;
}
degatsParTour(charId, pageId, effet, attrName, {
nbDe: 1,
de: 6
}, 'normal',
"saigne par tous les orifices du visage", evt, {
magique: true
},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'armureBrulante': //prend 1d4 DM
degatsParTour(charId, pageId, effet, attrName, {
nbDe: 1,
de: 4
}, 'feu',
"brûle dans son armure", evt, {},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'nueeDInsectes': //prend 1 DM
degatsParTour(charId, pageId, effet, attrName, {
cst: 1
}, 'normal',
"est piqué par les insectes", evt, {},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'armeBrulante': //prend 1 DM
degatsParTour(charId, pageId, effet, attrName, {
cst: 1
}, 'feu',
"se brûle avec son arme", evt, {},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'regeneration': //soigne
soigneParTour(charId, pageId, effet, attrName, 3, "régénère", evt, {
valeur: 'regenerationValeur'
},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
case 'strangulation':
var nameDureeStrang = 'dureeStrangulation';
if (effet != attrName) { //concerne un token non lié
nameDureeStrang += attrName.substring(attrName.indexOf('_'));
}
var dureeStrang = findObjs({
_type: 'attribute',
_characterid: charId,
name: nameDureeStrang
});
if (dureeStrang.length === 0) {
var attrDuree = createObj('attribute', {
characterid: charId,
name: nameDureeStrang,
current: 0,
max: false
});
evt.attributes.push({
attribute: attrDuree,
current: null
});
} else {
var strangUpdate = dureeStrang[0].get('max');
if (strangUpdate) { //a été mis à jour il y a au plus 1 tour
evt.attributes.push({
attribute: dureeStrang[0],
current: dureeStrang[0].get('current'),
max: strangUpdate
});
dureeStrang[0].set('max', false);
} else { //Ça fait trop longtemps, on arrête tout
sendChar(charId, messageEffetTemp[effet].fin);
attr.set('current', v);
evt.attributes.pop(); //On enlève des attributs modifiés pour mettre dans les attribute supprimés.
evt.deletedAttributes.push(attr);
attr.remove();
evt.deletedAttributes.push(dureeStrang[0]);
dureeStrang[0].remove();
}
}
count--;
return;
case 'dotGen':
var effetC = effetComplet(effet, attrName);
degatsParTour(charId, pageId, effetC, attrName, {}, '', "", evt, {
dotGen: true
},
function() {
count--;
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
});
return;
default:
count--;
return;
}
}
}); //fin de la boucle sur tous les attributs d'effets
}
if (count === 0) nextTurnOfActive(active, attrs, evt, pageId);
}
//Fonction appelée par !cof-tour-suivant
function tourSuivant(msg) {
if (!stateCOF.combat) {
sendPlayer(msg, "Vous n'êtes pas en combat");
return;
}
var cmp = Campaign();
var turnOrder = cmp.get('turnorder');
if (turnOrder === '') {
error("Personne n'est en combat", turnOrder);
return;
}
turnOrder = JSON.parse(turnOrder);
if (turnOrder.length < 1) {
error("Personne n'est en combat", turnOrder);
return;
}
var active = turnOrder.shift();
var persoActif = tokenOfId(active.id);
if (persoActif === undefined) {
error("Impossible de trouver le personnage actif", active);
return;
}
if (!peutController(msg, persoActif)) {
sendPlayer(msg, "Ce n'est pas votre tour (personnage actif : " + persoActif.token.get('name') + ")");
return;
}
turnOrder.push(active);
if (turnOrder[0].id == "-1" && turnOrder[0].custom == "Tour") {
//Il faut aussi augmenter la valeur du tour
var tour = parseInt(turnOrder[0].pr);
if (isNaN(tour)) {
error("Tour invalide", turnOrder);
return;
}
turnOrder[0].pr = tour + 1;
}
cmp.set('turnorder', JSON.stringify(turnOrder));
nextTurn(cmp);
}
//when set is true, sets the version, when false, remove it
function scriptVersionToCharacter(character, set) {
var charId = character.id;
var attrs = findObjs({
_type: 'attribute',
_characterid: charId,
name: 'scriptVersion',
}, {
caseInsensitive: true
});
if (attrs.length === 0) {
if (set) {
createObj('attribute', {
characterid: charId,
name: 'scriptVersion',
current: true,
max: state.COFantasy.version
});
}
} else {
if (set) {
attrs[0].set('current', true);
attrs[0].set('max', state.COFantasy.version);
} else {
attrs[0].set('current', false);
}
}
}
//evt a un champ attributes et un champ deletedAttributes
function nextTurnOfActive(active, attrs, evt, pageId) {
if (active.id == "-1" && active.custom == "Tour") {
// Nouveau tour
var tour = parseInt(active.pr);
if (isNaN(tour)) {
error("Tour invalide", active);
return;
}
evt.tour = tour - 1;
evt.updateNextInitSet = updateNextInitSet;
active.pr = tour - 1; // préparation au calcul de l'undo
sendChat("GM", "Début du tour " + tour);
stateCOF.tour = tour;
stateCOF.init = 1000;
// Enlever les bonus d'un tour
attrs = removeAllAttributes('actionConcertee', evt, attrs);
attrs = removeAllAttributes('intercepter', evt, attrs);
attrs = removeAllAttributes('interposer', evt, attrs);
attrs = removeAllAttributes('exemplaire', evt, attrs);
attrs = removeAllAttributes('peutEtreDeplace', evt, attrs);
attrs = removeAllAttributes('attaqueMalgreMenace', evt, attrs);
attrs = removeAllAttributes('ripostesDuTour', evt, attrs);
resetAttr(attrs, 'attaqueEnTraitre', evt);
resetAttr(attrs, 'esquiveAcrobatique', evt);
// Enlever attaque en meute gobelin
attrs = removeAllAttributes('attaqueParMeute', evt, attrs);
// Pour défaut dans la cuirasse, on diminue si la valeur est 2, et on supprime si c'est 1
var defautsDansLaCuirasse = allAttributesNamed(attrs, 'defautDansLaCuirasse');
defautsDansLaCuirasse.forEach(function(attr) {
if (attr.get('current') < 2) {
if (evt.deletedAttributes) evt.deletedAttributes.push(attr);
else evt.deletedAttributes = [attr];
attr.remove();
} else {
var prevAttr = {
attribute: attr,
current: 2
};
evt.attributes.push(prevAttr);
attr.set('current', 1);
}
});
// Pour la feinte, on augmente la valeur, et on supprime si la valeur est 2
var feinte = allAttributesNamed(attrs, 'feinte');
feinte.forEach(function(attr) {
var valFeinte = parseInt(attr.get('current'));
if (isNaN(valFeinte) || valFeinte > 0) {
evt.deletedAttributes.push(attr);
attr.remove();
} else {
var prevAttr = {
attribute: attr,
current: 0
};
evt.attributes.push(prevAttr);
attr.set('current', 1);
}
});
var vapeth = allAttributesNamed(attrs, 'vapeursEthyliques');
vapeth.forEach(function(attr) {
var ve = parseInt(attr.get('current'));
if (isNaN(ve)) ve = 0;
evt.attributes.push({
attribute: attr,
current: 0
});
attr.set('current', ve + 1);
var veCharId = attr.get('characterid');
if (veCharId === undefined || veCharId === '') {
error("Attribut sans personnage associé", attr);
return;
}
var veSeuil = parseInt(attr.get('max'));
if (isNaN(veSeuil)) veSeuil = 0;
veSeuil -= Math.floor(ve / 2);
iterTokensOfAttribute(veCharId, stateCOF.combat_pageid,
'vapeursEthyliques', attr.get('name'),
function(tok) {
var perso = {
charId: veCharId,
token: tok
};
testCaracteristique(perso, 'CON', veSeuil, {}, evt, function(testRes) {
var res = "tente un jet de CON " + veSeuil + " pour combattre les vapeurs éthyliques " + testRes.texte;
if (testRes.reussite) {
res += " => réussi";
var expliquer;
if (attr.get('name') == 'vapeursEthyliques') {
expliquer = function(s) {
sendChar(veCharId, s);
};
} else {
perso.tokName = tok.get('name');
expliquer = function(s) {
sendChat('', perso.tokName + ' ' + s);
};
}
expliquer(res);
diminueEbriete(perso, evt, expliquer);
} else {
res += " => raté";
sendChar(veCharId, res);
}
});
});
});
// nouveau tour : enlever le statut surpris
// et faire les actions de début de tour
var selected = [];
updateNextInitSet.forEach(function(id) {
selected.push({
_id: id
});
});
findObjs({
_type: 'graphic',
_subtype: 'token',
_pageid: pageId
}).forEach(function(tok) {
var charId = tok.get('represents');
if (charId === '') return;
var perso = {
token: tok,
charId: charId
};
if (getState(perso, 'surpris')) { //surprise
setState(perso, 'surpris', false, {});
selected.push({
_id: tok.id
});
}
var enflammeAttr = tokenAttribute(perso, 'enflamme');
if (enflammeAttr.length > 0) {
var enflamme = parseInt(enflammeAttr[0].get('current'));
// Pour ne pas faire les dégâts plusieurs fois (plusieurs tokens pour un même personnage), on utilise la valeur max de l'attribut
var dernierTourEnflamme = parseInt(enflammeAttr[0].get('max'));
if ((isNaN(dernierTourEnflamme) || dernierTourEnflamme < tour) &&
!isNaN(enflamme) && enflamme > 0) {
var d6Enflamme = randomInteger(6);
var feu = d6Enflamme + enflamme - 1;
var dmg = {
type: 'feu',
total: feu,
display: feu
};
feu = dealDamage(perso, dmg, [], evt);
sendChar(charId, " est en flamme ! " +
onGenre(charId, 'Il', 'Elle') + " subit " + feu + " DM");
if (d6Enflamme < 3) {
sendChar(charId, " les flammes s'éteignent");
removeTokenAttr(perso, 'enflamme', evt);
} else {
enflammeAttr[0].set('max', tour);
}
}
}
var vitaliteSurnatAttr = charAttribute(perso.charId, 'vitaliteSurnaturelle');
if (vitaliteSurnatAttr.length > 0) {
var vitaliteSurnat = parseInt(vitaliteSurnatAttr[0].get('current'));
if (vitaliteSurnat > 0) {
soigneToken(perso, vitaliteSurnat, evt,
function(s) {
sendChar(charId, 'récupère ' + s + ' PVs.');
},
function() {}, {
saufDMType: vitaliteSurnatAttr[0].get('max').split(',')
}
);
}
}
});
setActiveToken(undefined, evt);
initiative(selected, evt, true); // met Tour à la fin et retrie
updateNextInitSet = new Set();
// Saves à faire à la fin de chaque tour
var attrsSave = attrs.filter(function(attr) {
var attrName = attr.get('name');
var indexSave = attrName.indexOf('SaveParTour');
if (indexSave < 0) return false;
return estEffetTemp(attrName.substring(0, indexSave));
});
//Les saves sont asynchrones
var count = attrsSave.length;
attrsSave.forEach(function(attr) {
var attrName = attr.get('name');
var carac = attr.get('current');
if (!isCarac(carac)) {
error("Save par tour " + attrName + " mal formé", carac);
count--;
if (count === 0) addEvent(evt);
return;
}
var seuil = parseInt(attr.get('max'));
if (isNaN(seuil)) {
error("Save par tour " + attrName + " mal formé", seuil);
count--;
if (count === 0) addEvent(evt);
return;
}
var charId = attr.get('characterid');
var indexSave = attrName.indexOf('SaveParTour');
var effetC = attrName.substring(0, indexSave);
attrName = effetC + attrName.substr(indexSave + 11);
var token;
iterTokensOfAttribute(charId, pageId, effetC, attrName, function(tok) {
if (token === undefined) token = tok;
});
if (token === undefined) {
log("Pas de token pour le save " + attrName);
count--;
if (count === 0) addEvent(evt);
return;
}
var perso = {
token: token,
charId: charId
};
if (getState(perso, 'mort')) {
count--;
if (count === 0) addEvent(evt);
return;
}
var attrEffet = findObjs({
_type: 'attribute',
_characterid: charId,
name: attrName
});
if (attrEffet === undefined || attrEffet.length === 0) {
error("Save sans effet temporaire " + attrName, attr);
attr.remove();
count--;
if (count === 0) addEvent(evt);
return;
}
attrEffet = attrEffet[0];
var expliquer = function(msg) {
sendChar(charId, msg);
};
var msgPour = " pour ne plus être sous l'effet de ";
if (effetC.startsWith('dotGen('))
msgPour += effetC.substring(7, effetC.indexOf(')'));
else msgPour += effetC;
var sujet = onGenre(charId, 'il', 'elle');
var met = messageOfEffetTemp(effetC);
var msgReussite = ", " + sujet + " " + met.fin;
var msgRate = ", " + sujet + " " + met.actif;
var saveOpts = {
msgPour: msgPour,
msgReussite: msgReussite,
msgRate: msgRate
};
save({
carac: carac,
seuil: seuil
}, perso, expliquer, saveOpts, evt,
function(reussite) { //asynchrone
if (reussite) {
finDEffet(attrEffet, effetC, attrName, charId, evt, {
attrSave: attr,
pageId: pageId
});
}
count--;
if (count === 0) addEvent(evt);
});
}); //fin boucle attrSave
} else { // change the active token
setActiveToken(active.id, evt);
}
addEvent(evt);
}
function destroyToken(token) { //to remove unused local attributes
var charId = token.get('represents');
if (charId === "") return;
if (token.get('bar1_link') !== "") return;
var endName = "_" + token.get('name');
var tokAttr = findObjs({
_type: 'attribute',
_characterid: charId
});
tokAttr = tokAttr.filter(function(obj) {
return obj.get('name').endsWith(endName);
});
if (tokAttr.length > 0) {
log("Removing token local attributes");
log(tokAttr);
tokAttr.forEach(function(attr) {
attr.remove();
});
}
}
function nePeutPasBouger(perso) {
if (attributeAsBool(perso, 'peutEtreDeplace')) return false;
if (isActive(perso)) {
if (getState(perso, 'immobilise')) return true;
if (attributeAsBool(perso, 'bloqueManoeuvre')) return true;
if (attributeAsBool(perso, 'enveloppePar')) return true;
return false;
}
return true;
}
function permettreDeplacement(msg) {
getSelected(msg, function(selected) {
var evt = {
type: 'Permettre le déplacement pour un tour'
};
iterSelected(selected, function(perso) {
setTokenAttr(perso, 'peutEtreDeplace', true, evt);
});
addEvent(evt);
});
}
//Réagit au déplacement manuel d'un token.
function moveToken(token, prev) {
var charId = token.get('represents');
if (charId === '') return;
var perso = {
token: token,
charId: charId
};
var pageId = token.get('pageid');
var x = token.get('left');
var y = token.get('top');
var deplacement = prev && (prev.left != x || prev.top != y);
if (deplacement) {
if (nePeutPasBouger(perso)) {
sendChar(charId, "ne peut pas se déplacer.");
sendChat('COF', "/w GM " +
'<a href="!cof-deplacer-token ' + x + ' ' + y + ' --target ' + token.id + '">Déplacer </a>' +
'<a href="!cof-permettre-deplacement --target ' + token.id + '">Décoincer</a>');
token.set('left', prev.left);
token.set('top', prev.top);
return;
} else {
//On déplace les tokens de lumière, si il y en a
var attrLumiere = tokenAttribute(perso, 'lumiere');
attrLumiere.forEach(function(al) {
var lumId = al.get('max');
if (lumId == 'surToken') return;
var lumiere = getObj('graphic', lumId);
if (lumiere && lumiere.get('pageid') != pageId) lumiere = undefined;
if (lumiere === undefined) {
var tokensLumiere = findObjs({
_type: 'graphic',
_pageid: pageId,
layer: 'walls',
name: al.get('current')
});
if (tokensLumiere.length === 0) {
log("Pas de token pour la lumière " + al.get('current'));
al.remove();
return;
}
lumiere = tokensLumiere.shift();
if (tokensLumiere.length > 0) {
//On cherche le token le plus proche de la position précédente
var d =
VecMath.length(
VecMath.vec([lumiere.get('left'), lumiere.get('top')], [prev.left, prev.top]));
tokensLumiere.forEach(function(tl) {
var d2 =
VecMath.length(
VecMath.vec([tl.get('left'), tl.get('top')], [prev.left, prev.top]));
if (d2 < d) {
d = d2;
lumiere = tl;
}
});
}
}
if (lumiere === undefined) {
log("Pas de token pour la lumière " + al.get('current'));
al.remove();
return;
}
lumiere.set('left', x);
lumiere.set('top', y);
});
}
}
//On regarde d'abord si perso est sur une monture
var attr = tokenAttribute(perso, 'monteSur');
if (attr.length > 0) {
if (deplacement) {
attr[0].remove();
var monture = tokenOfId(attr[0].get('current'), attr[0].get('max'), pageId);
if (monture === undefined) {
sendChar(charId, "descend de sa monture");
return;
}
sendChar(charId, "descend de " + monture.token.get('name'));
removeTokenAttr(monture, 'estMontePar');
removeTokenAttr(monture, 'positionSurMonture');
}
return;
}
//si non, perso est peut-être une monture
attr = tokenAttribute(perso, 'estMontePar');
attr.forEach(function(a) {
var cavalier = tokenOfId(a.get('current'), a.get('max'), pageId);
if (cavalier === undefined) {
a.remove();
return;
}
var position = tokenAttribute(perso, 'positionSurMonture');
if (position.length > 0) {
var dx = parseInt(position[0].get('current'));
var dy = parseInt(position[0].get('max'));
if (!(isNaN(dx) || isNaN(dy))) {
x += dx;
y += dy;
}
}
cavalier.token.set('left', x);
cavalier.token.set('top', y);
cavalier.token.set('rotation', token.get('rotation') + attributeAsInt(perso, 'directionSurMonture', 0));
});
attr = tokenAttribute(perso, 'enveloppe');
attr.forEach(function(a) {
var cible = tokenOfIdName(a.get('current'), pageId);
if (cible === undefined) {
a.remove();
return;
}
cible.token.set('left', x);
cible.token.set('top', y);
});
}
function deplacerToken(msg) {
var cmd = msg.content.split(' ');
if (cmd.length < 3) {
error("Il manque un argument à !cof-deplacer-token", cmd);
return;
}
getSelected(msg, function(selected) {
if (selected.length === 0) {
error("Il faut sélectionner un token", cmd);
return;
}
if (selected.length > 1) {
error("Déplacement de plusieurs tokens au même endroit", selected);
return;
}
iterSelected(selected, function(perso) {
perso.token.set('left', cmd[1]);
perso.token.set('top', cmd[2]);
moveToken(perso.token);
});
});
}
//Si le token représente un personnage et avec la barre de vie non liée,
// assure un nom unique en ajoutant un numéro
// On en profite aussi pour mettre certaines valeurs par défaut
function renameToken(token, tokenName) {
var charId = token.get('represents');
if (charId === undefined || charId === '') return;
var perso = {
token: token,
tokName: tokenName,
charId: charId
};
//Vision
var visionNoir = charAttributeAsInt(perso, 'visionDansLeNoir', 0);
if (visionNoir > 0) {
token.set('light_radius', visionNoir);
token.set('light_dimradius', -1);
token.set('light_otherplayers', false);
token.set('light_hassight', true);
token.set('light_angle', 360);
}
if (token.get('bar1_link') !== '') return;
var copyOf = 0;
var tokenBaseName = tokenName;
if (tokenBaseName.includes('%%NUMBERED%%')) {
if (typeof TokenNameNumber !== 'undefined') return; //On laisse tokenNameNumber gérer ça
tokenBaseName = tokenBaseName.replace('%%NUMBERED%%', '');
} else {
// On regarde si le nom se termine par un entier
var lastSpace = tokenBaseName.lastIndexOf(' ');
if (lastSpace > 0) {
copyOf = +tokenBaseName.substring(lastSpace + 1);
if (isNaN(copyOf)) copyOf = 0;
else tokenBaseName = tokenBaseName.substring(0, lastSpace);
}
}
var otherTokens = findObjs({
_type: 'graphic',
//_pageid: token.get('pageid'),
represents: charId
});
otherTokens = otherTokens.filter(function(tok) {
var pid = tok.get('pageid');
var page = getObj('page', pid);
if (page) {
return !(page.get('archived'));
}
return false;
});
var numero = 1;
var nePasModifier = false;
if (typeof TokenNameNumber !== 'undefined' && tokenBaseName.length > 0) {
if (!isNaN(tokenBaseName[tokenBaseName.length - 1]))
nePasModifier = true;
}
var pageId = token.get('pageid');
otherTokens.forEach(function(ot) {
if (ot.id == token.id) return;
var name = ot.get('name');
if (nePasModifier && name == tokenBaseName) nePasModifier = false;
if (name.startsWith(tokenBaseName)) {
var suffixe = name.replace(tokenBaseName + ' ', '');
if (isNaN(suffixe)) return;
var n = parseInt(suffixe);
if (n == copyOf) {
if (ot.get('pageid') == pageId) copyOf = 0;
}
if (n >= numero) numero = n + 1;
}
});
if (nePasModifier || copyOf > 0) return;
token.set('name', tokenBaseName + ' ' + numero);
}
function addToken(token, nb) {
var tokenName = token.get('name');
//La plupart du temps, il faut attendre un peu que le nom soit affecté
if (tokenName !== '') {
renameToken(token, tokenName);
return;
}
nb = nb || 1;
if (nb > 10) return; //Tant pis, peut-être que le nom est vide
_.delay(function() {
addToken(token, nb + 1);
}, 50);
}
return {
apiCommand: apiCommand,
nextTurn: nextTurn,
destroyToken: destroyToken,
moveToken: moveToken,
changeHandout: changeHandout,
addToken: addToken,
setStateCOF: setStateCOF,
scriptVersionToCharacter: scriptVersionToCharacter,
};
}();
on("change:handout", function(obj, prev) {
COFantasy.changeHandout(obj, prev);
});
on("destroy:handout", function(prev) {
COFantasy.changeHandout(undefined, prev);
});
on("ready", function() {
var script_version = "2.0";
on('add:token', COFantasy.addToken);
state.COFantasy = state.COFantasy || {
combat: false,
tour: 0,
init: 1000,
eventId: 0,
version: script_version,
};
COFantasy.setStateCOF();
if (state.COFantasy.version === undefined) {
state.COFantasy.eventId = 0;
}
var handout = findObjs({
_type: 'handout'
});
var strReg;
var regName;
var regText;
var attrs;
var macros;
if (state.COFantasy.version < 1.0) {
log("Mise à jour des attributs et macros vers la version 1.0");
//Mise à jour des effets temporaires avec _
strReg = "(rayon_affaiblissant|peau_d_ecorce|chant_des_heros|image_decalee|a_couvert|sous_tension|forgeron_|armeEnflammee)";
regName = new RegExp("^" + strReg);
regText = new RegExp(strReg);
attrs = findObjs({
_type: 'attribute',
});
attrs.forEach(function(attr) {
var attrName = attr.get('name');
if (regName.test(attrName)) {
attrName = attrName.replace(/rayon_affaiblissant/, 'rayonAffaiblissant');
attrName = attrName.replace(/peau_d_ecorce/, 'peauDEcorce');
attrName = attrName.replace(/chant_des_heros/, 'chantDesHeros');
attrName = attrName.replace(/image_decalee/, 'imageDecalee');
attrName = attrName.replace(/a_couvert/, 'aCouvert');
attrName = attrName.replace(/sous_tension/, 'sousTension');
attrName = attrName.replace(/forgeron_([^_\s)]*)/, 'forgeron($1)');
attrName = attrName.replace(/armeEnflammee([^_\s)]*)/, 'armeEnflammee($1)');
attr.set('name', attrName);
}
//Pour les consommables, il faut aussi changer le champ max;
var attrMax = attr.get('max');
if (regText.test(attrMax)) {
attrMax = attrMax.replace(/rayon_affaiblissant/g, 'rayonAffaiblissant');
attrMax = attrMax.replace(/peau_d_ecorce/g, 'peauDEcorce');
attrMax = attrMax.replace(/chant_des_heros/g, 'chantDesHeros');
attrMax = attrMax.replace(/image_decalee/g, 'imageDecalee');
attrMax = attrMax.replace(/a_couvert/g, 'aCouvert');
attrMax = attrMax.replace(/sous_tension/g, 'sousTension');
attrMax = attrMax.replace(/forgeron_([^_\s)]*)/g, 'forgeron($1)');
attrMax = attrMax.replace(/armeEnflammee([^_\s)]*)/g, 'armeEnflammee($1)');
attr.set('max', attrMax);
}
});
macros = findObjs({
_type: 'macro'
}).concat(findObjs({
_type: 'ability'
}));
macros.forEach(function(m) {
var action = m.get('action');
if (regText.test(action)) {
action = action.replace(/rayon_affaiblissant/g, 'rayonAffaiblissant');
action = action.replace(/peau_d_ecorce/g, 'peauDEcorce');
action = action.replace(/chant_des_heros/g, 'chantDesHeros');
action = action.replace(/image_decalee/g, 'imageDecalee');
action = action.replace(/a_couvert/g, 'aCouvert');
action = action.replace(/sous_tension/g, 'sousTension');
action = action.replace(/forgeron_([^_\s)]*)/g, 'forgeron($1)');
action = action.replace(/armeEnflammee([^_\s)]*)/g, 'armeEnflammee($1)');
m.set('action', action);
}
});
log("Mise à jour effectuée.");
}
if (state.COFantasy.version < 2.0) {
log("Mise à jour des attributs et macros vers la version 2.0");
strReg = "(--argent)";
regName = new RegExp("^" + strReg);
regText = new RegExp(strReg);
attrs = findObjs({
_type: 'attribute',
});
attrs.forEach(function(attr) {
var attrName = attr.get('name');
if (regName.test(attrName)) {
attrName = attrName.replace(/--argent/, '--armeDArgent');
attr.set('name', attrName);
}
//Pour les consommables, il faut aussi changer le champ max;
var attrMax = attr.get('max');
if (regText.test(attrMax)) {
attrMax = attrMax.replace(/--argent/g, '--armeDArgent');
attr.set('max', attrMax);
}
});
macros = findObjs({
_type: 'macro'
}).concat(findObjs({
_type: 'ability'
}));
macros.forEach(function(m) {
var action = m.get('action');
if (regText.test(action)) {
action = action.replace(/--argent/g, '--armeDArgent');
m.set('action', action);
}
});
//On met un attribut scriptVersion dans toutes les fiches
findObjs({
_type: 'character'
}).forEach(function(c) {
createObj('attribute', {
characterid: c.id,
name: 'scriptVersion',
current: true,
max: script_version
});
state.COFantasy.scriptSheets = true;
});
log("Mise à jour effectuée.");
}
state.COFantasy.version = script_version;
if (state.COFantasy.options.affichage.val.fiche.val) {
if (!state.COFantasy.scriptSheets) {
findObjs({
_type: 'character'
}).forEach(function(c) {
COFantasy.scriptVersionToCharacter(c, true);
});
}
} else {
if (state.COFantasy.scriptSheets) {
findObjs({
_type: 'character'
}).forEach(function(c) {
COFantasy.scriptVersionToCharacter(c, false);
});
}
}
handout.forEach(function(hand) {
COFantasy.changeHandout(hand);
});
COF_loaded = true;
log("COFantasy " + script_version + " loaded");
});
on("chat:message", function(msg) {
"use strict";
if (COF_loaded && msg.type == "api" && msg.content.startsWith('!cof-'))
COFantasy.apiCommand(msg);
});
on("change:campaign:turnorder", COFantasy.nextTurn);
on("destroy:token", COFantasy.destroyToken);
on("change:token:left", COFantasy.moveToken);
on("change:token:top", COFantasy.moveToken);
on("change:token:rotation", COFantasy.moveToken);
on("add:character", function(c) {
if (COF_loaded && state.COFantasy.scriptSheets) {
COFantasy.scriptVersionToCharacter(c, true);
}
});
|
define({
"left": "Linksbündig",
"right": "Rechtsbündig",
"arrangement": "Anordnung",
"autoUpdate": "Automatisch aktualisieren",
"respectCurrentMapScale": "Aktuellen Kartenmaßstab berücksichtigen",
"layerSelectorTitle": "Layer auswählen, in denen Legenden angezeigt werden sollen: ",
"showLegendsForLayers": "Legenden für Layer anzeigen:",
"showBasemapLegends": "Grundkartenlegenden anzeigen",
"honorTheWebMapSetting": "Einstellung der Webkarte berücksichtigen",
"reset": "Zurücksetzen",
"resetTip": "Auf die ursprüngliche Einstellung der Webkarte zurücksetzen"
});
|
/*!
* Bootstrap v4.0.0 (https://getbootstrap.com)
* Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) :
typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) :
(factory((global.bootstrap = {}),global.jQuery,global.Popper));
}(this, (function (exports,$,Popper) { 'use strict';
$ = $ && $.hasOwnProperty('default') ? $['default'] : $;
Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _extends() {
_extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
subClass.__proto__ = superClass;
}
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): util.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Util = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Private TransitionEnd Helpers
* ------------------------------------------------------------------------
*/
var transition = false;
var MAX_UID = 1000000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
function toType(obj) {
return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
}
function getSpecialTransitionEndEvent() {
return {
bindType: transition.end,
delegateType: transition.end,
handle: function handle(event) {
if ($$$1(event.target).is(this)) {
return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
}
return undefined; // eslint-disable-line no-undefined
}
};
}
function transitionEndTest() {
if (typeof window !== 'undefined' && window.QUnit) {
return false;
}
return {
end: 'transitionend'
};
}
function transitionEndEmulator(duration) {
var _this = this;
var called = false;
$$$1(this).one(Util.TRANSITION_END, function () {
called = true;
});
setTimeout(function () {
if (!called) {
Util.triggerTransitionEnd(_this);
}
}, duration);
return this;
}
function setTransitionEndSupport() {
transition = transitionEndTest();
$$$1.fn.emulateTransitionEnd = transitionEndEmulator;
if (Util.supportsTransitionEnd()) {
$$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
}
}
/**
* --------------------------------------------------------------------------
* Public Util Api
* --------------------------------------------------------------------------
*/
var Util = {
TRANSITION_END: 'bsTransitionEnd',
getUID: function getUID(prefix) {
do {
// eslint-disable-next-line no-bitwise
prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
} while (document.getElementById(prefix));
return prefix;
},
getSelectorFromElement: function getSelectorFromElement(element) {
var selector = element.getAttribute('data-target');
if (!selector || selector === '#') {
selector = element.getAttribute('href') || '';
}
try {
var $selector = $$$1(document).find(selector);
return $selector.length > 0 ? selector : null;
} catch (err) {
return null;
}
},
reflow: function reflow(element) {
return element.offsetHeight;
},
triggerTransitionEnd: function triggerTransitionEnd(element) {
$$$1(element).trigger(transition.end);
},
supportsTransitionEnd: function supportsTransitionEnd() {
return Boolean(transition);
},
isElement: function isElement(obj) {
return (obj[0] || obj).nodeType;
},
typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
for (var property in configTypes) {
if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
var expectedTypes = configTypes[property];
var value = config[property];
var valueType = value && Util.isElement(value) ? 'element' : toType(value);
if (!new RegExp(expectedTypes).test(valueType)) {
throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
}
}
}
}
};
setTransitionEndSupport();
return Util;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): alert.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Alert = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'alert';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.alert';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var TRANSITION_DURATION = 150;
var Selector = {
DISMISS: '[data-dismiss="alert"]'
};
var Event = {
CLOSE: "close" + EVENT_KEY,
CLOSED: "closed" + EVENT_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
ALERT: 'alert',
FADE: 'fade',
SHOW: 'show'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Alert =
/*#__PURE__*/
function () {
function Alert(element) {
this._element = element;
} // Getters
var _proto = Alert.prototype;
// Public
_proto.close = function close(element) {
element = element || this._element;
var rootElement = this._getRootElement(element);
var customEvent = this._triggerCloseEvent(rootElement);
if (customEvent.isDefaultPrevented()) {
return;
}
this._removeElement(rootElement);
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
this._element = null;
}; // Private
_proto._getRootElement = function _getRootElement(element) {
var selector = Util.getSelectorFromElement(element);
var parent = false;
if (selector) {
parent = $$$1(selector)[0];
}
if (!parent) {
parent = $$$1(element).closest("." + ClassName.ALERT)[0];
}
return parent;
};
_proto._triggerCloseEvent = function _triggerCloseEvent(element) {
var closeEvent = $$$1.Event(Event.CLOSE);
$$$1(element).trigger(closeEvent);
return closeEvent;
};
_proto._removeElement = function _removeElement(element) {
var _this = this;
$$$1(element).removeClass(ClassName.SHOW);
if (!Util.supportsTransitionEnd() || !$$$1(element).hasClass(ClassName.FADE)) {
this._destroyElement(element);
return;
}
$$$1(element).one(Util.TRANSITION_END, function (event) {
return _this._destroyElement(element, event);
}).emulateTransitionEnd(TRANSITION_DURATION);
};
_proto._destroyElement = function _destroyElement(element) {
$$$1(element).detach().trigger(Event.CLOSED).remove();
}; // Static
Alert._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var $element = $$$1(this);
var data = $element.data(DATA_KEY);
if (!data) {
data = new Alert(this);
$element.data(DATA_KEY, data);
}
if (config === 'close') {
data[config](this);
}
});
};
Alert._handleDismiss = function _handleDismiss(alertInstance) {
return function (event) {
if (event) {
event.preventDefault();
}
alertInstance.close(this);
};
};
_createClass(Alert, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}]);
return Alert;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Alert._jQueryInterface;
$$$1.fn[NAME].Constructor = Alert;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Alert._jQueryInterface;
};
return Alert;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): button.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Button = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'button';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.button';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var ClassName = {
ACTIVE: 'active',
BUTTON: 'btn',
FOCUS: 'focus'
};
var Selector = {
DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
DATA_TOGGLE: '[data-toggle="buttons"]',
INPUT: 'input',
ACTIVE: '.active',
BUTTON: '.btn'
};
var Event = {
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY + DATA_API_KEY + " " + ("blur" + EVENT_KEY + DATA_API_KEY)
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Button =
/*#__PURE__*/
function () {
function Button(element) {
this._element = element;
} // Getters
var _proto = Button.prototype;
// Public
_proto.toggle = function toggle() {
var triggerChangeEvent = true;
var addAriaPressed = true;
var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
if (rootElement) {
var input = $$$1(this._element).find(Selector.INPUT)[0];
if (input) {
if (input.type === 'radio') {
if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
triggerChangeEvent = false;
} else {
var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
if (activeElement) {
$$$1(activeElement).removeClass(ClassName.ACTIVE);
}
}
}
if (triggerChangeEvent) {
if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
return;
}
input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
$$$1(input).trigger('change');
}
input.focus();
addAriaPressed = false;
}
}
if (addAriaPressed) {
this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
}
if (triggerChangeEvent) {
$$$1(this._element).toggleClass(ClassName.ACTIVE);
}
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
this._element = null;
}; // Static
Button._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
if (!data) {
data = new Button(this);
$$$1(this).data(DATA_KEY, data);
}
if (config === 'toggle') {
data[config]();
}
});
};
_createClass(Button, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}]);
return Button;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
event.preventDefault();
var button = event.target;
if (!$$$1(button).hasClass(ClassName.BUTTON)) {
button = $$$1(button).closest(Selector.BUTTON);
}
Button._jQueryInterface.call($$$1(button), 'toggle');
}).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
var button = $$$1(event.target).closest(Selector.BUTTON)[0];
$$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Button._jQueryInterface;
$$$1.fn[NAME].Constructor = Button;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Button._jQueryInterface;
};
return Button;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): carousel.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Carousel = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'carousel';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.carousel';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
var MILLISECONDS_MULTIPLIER = 1000;
var Default = {
interval: 5000,
keyboard: true,
slide: false,
pause: 'hover',
wrap: true
};
var DefaultType = {
interval: '(number|boolean)',
keyboard: 'boolean',
slide: '(boolean|string)',
pause: '(string|boolean)',
wrap: 'boolean'
};
var Direction = {
NEXT: 'next',
PREV: 'prev',
LEFT: 'left',
RIGHT: 'right'
};
var Event = {
SLIDE: "slide" + EVENT_KEY,
SLID: "slid" + EVENT_KEY,
KEYDOWN: "keydown" + EVENT_KEY,
MOUSEENTER: "mouseenter" + EVENT_KEY,
MOUSELEAVE: "mouseleave" + EVENT_KEY,
TOUCHEND: "touchend" + EVENT_KEY,
LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
CAROUSEL: 'carousel',
ACTIVE: 'active',
SLIDE: 'slide',
RIGHT: 'carousel-item-right',
LEFT: 'carousel-item-left',
NEXT: 'carousel-item-next',
PREV: 'carousel-item-prev',
ITEM: 'carousel-item'
};
var Selector = {
ACTIVE: '.active',
ACTIVE_ITEM: '.active.carousel-item',
ITEM: '.carousel-item',
NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
INDICATORS: '.carousel-indicators',
DATA_SLIDE: '[data-slide], [data-slide-to]',
DATA_RIDE: '[data-ride="carousel"]'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Carousel =
/*#__PURE__*/
function () {
function Carousel(element, config) {
this._items = null;
this._interval = null;
this._activeElement = null;
this._isPaused = false;
this._isSliding = false;
this.touchTimeout = null;
this._config = this._getConfig(config);
this._element = $$$1(element)[0];
this._indicatorsElement = $$$1(this._element).find(Selector.INDICATORS)[0];
this._transitionDuration = this._getTransitionDuration();
this._addEventListeners();
} // Getters
var _proto = Carousel.prototype;
// Public
_proto.next = function next() {
if (!this._isSliding) {
this._slide(Direction.NEXT);
}
};
_proto.nextWhenVisible = function nextWhenVisible() {
// Don't call next when the page isn't visible
// or the carousel or its parent isn't visible
if (!document.hidden && $$$1(this._element).is(':visible') && $$$1(this._element).css('visibility') !== 'hidden') {
this.next();
}
};
_proto.prev = function prev() {
if (!this._isSliding) {
this._slide(Direction.PREV);
}
};
_proto.pause = function pause(event) {
if (!event) {
this._isPaused = true;
}
if ($$$1(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) {
Util.triggerTransitionEnd(this._element);
this.cycle(true);
}
clearInterval(this._interval);
this._interval = null;
};
_proto.cycle = function cycle(event) {
if (!event) {
this._isPaused = false;
}
if (this._interval) {
clearInterval(this._interval);
this._interval = null;
}
if (this._config.interval && !this._isPaused) {
this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
}
};
_proto.to = function to(index) {
var _this = this;
this._activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
var activeIndex = this._getItemIndex(this._activeElement);
if (index > this._items.length - 1 || index < 0) {
return;
}
if (this._isSliding) {
$$$1(this._element).one(Event.SLID, function () {
return _this.to(index);
});
return;
}
if (activeIndex === index) {
this.pause();
this.cycle();
return;
}
var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
this._slide(direction, this._items[index]);
};
_proto.dispose = function dispose() {
$$$1(this._element).off(EVENT_KEY);
$$$1.removeData(this._element, DATA_KEY);
this._items = null;
this._config = null;
this._element = null;
this._interval = null;
this._isPaused = null;
this._isSliding = null;
this._activeElement = null;
this._indicatorsElement = null;
}; // Private
_proto._getConfig = function _getConfig(config) {
config = _extends({}, Default, config);
Util.typeCheckConfig(NAME, config, DefaultType);
return config;
};
_proto._getTransitionDuration = function _getTransitionDuration() {
// Get transition-duration of first element in the carousel
var transitionDuration = $$$1(this._element).find(Selector.ITEM).css('transition-duration'); // Return 0 carousel item is not found
if (!transitionDuration) {
return 0;
} // If multiple durations are defined, take the first
transitionDuration = transitionDuration.split(',')[0]; // Multiply by 1000 if transition-duration is defined in seconds
return transitionDuration.indexOf('ms') > -1 ? parseFloat(transitionDuration) : parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER;
};
_proto._addEventListeners = function _addEventListeners() {
var _this2 = this;
if (this._config.keyboard) {
$$$1(this._element).on(Event.KEYDOWN, function (event) {
return _this2._keydown(event);
});
}
if (this._config.pause === 'hover') {
$$$1(this._element).on(Event.MOUSEENTER, function (event) {
return _this2.pause(event);
}).on(Event.MOUSELEAVE, function (event) {
return _this2.cycle(event);
});
if ('ontouchstart' in document.documentElement) {
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// would stop cycling until user tapped out of it;
// here, we listen for touchend, explicitly pause the carousel
// (as if it's the second time we tap on it, mouseenter compat event
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
$$$1(this._element).on(Event.TOUCHEND, function () {
_this2.pause();
if (_this2.touchTimeout) {
clearTimeout(_this2.touchTimeout);
}
_this2.touchTimeout = setTimeout(function (event) {
return _this2.cycle(event);
}, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
});
}
}
};
_proto._keydown = function _keydown(event) {
if (/input|textarea/i.test(event.target.tagName)) {
return;
}
switch (event.which) {
case ARROW_LEFT_KEYCODE:
event.preventDefault();
this.prev();
break;
case ARROW_RIGHT_KEYCODE:
event.preventDefault();
this.next();
break;
default:
}
};
_proto._getItemIndex = function _getItemIndex(element) {
this._items = $$$1.makeArray($$$1(element).parent().find(Selector.ITEM));
return this._items.indexOf(element);
};
_proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
var isNextDirection = direction === Direction.NEXT;
var isPrevDirection = direction === Direction.PREV;
var activeIndex = this._getItemIndex(activeElement);
var lastItemIndex = this._items.length - 1;
var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
if (isGoingToWrap && !this._config.wrap) {
return activeElement;
}
var delta = direction === Direction.PREV ? -1 : 1;
var itemIndex = (activeIndex + delta) % this._items.length;
return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
};
_proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
var targetIndex = this._getItemIndex(relatedTarget);
var fromIndex = this._getItemIndex($$$1(this._element).find(Selector.ACTIVE_ITEM)[0]);
var slideEvent = $$$1.Event(Event.SLIDE, {
relatedTarget: relatedTarget,
direction: eventDirectionName,
from: fromIndex,
to: targetIndex
});
$$$1(this._element).trigger(slideEvent);
return slideEvent;
};
_proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
if (this._indicatorsElement) {
$$$1(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
if (nextIndicator) {
$$$1(nextIndicator).addClass(ClassName.ACTIVE);
}
}
};
_proto._slide = function _slide(direction, element) {
var _this3 = this;
var activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
var activeElementIndex = this._getItemIndex(activeElement);
var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
var nextElementIndex = this._getItemIndex(nextElement);
var isCycling = Boolean(this._interval);
var directionalClassName;
var orderClassName;
var eventDirectionName;
if (direction === Direction.NEXT) {
directionalClassName = ClassName.LEFT;
orderClassName = ClassName.NEXT;
eventDirectionName = Direction.LEFT;
} else {
directionalClassName = ClassName.RIGHT;
orderClassName = ClassName.PREV;
eventDirectionName = Direction.RIGHT;
}
if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
this._isSliding = false;
return;
}
var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
if (slideEvent.isDefaultPrevented()) {
return;
}
if (!activeElement || !nextElement) {
// Some weirdness is happening, so we bail
return;
}
this._isSliding = true;
if (isCycling) {
this.pause();
}
this._setActiveIndicatorElement(nextElement);
var slidEvent = $$$1.Event(Event.SLID, {
relatedTarget: nextElement,
direction: eventDirectionName,
from: activeElementIndex,
to: nextElementIndex
});
if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.SLIDE)) {
$$$1(nextElement).addClass(orderClassName);
Util.reflow(nextElement);
$$$1(activeElement).addClass(directionalClassName);
$$$1(nextElement).addClass(directionalClassName);
$$$1(activeElement).one(Util.TRANSITION_END, function () {
$$$1(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName.ACTIVE);
$$$1(activeElement).removeClass(ClassName.ACTIVE + " " + orderClassName + " " + directionalClassName);
_this3._isSliding = false;
setTimeout(function () {
return $$$1(_this3._element).trigger(slidEvent);
}, 0);
}).emulateTransitionEnd(this._transitionDuration);
} else {
$$$1(activeElement).removeClass(ClassName.ACTIVE);
$$$1(nextElement).addClass(ClassName.ACTIVE);
this._isSliding = false;
$$$1(this._element).trigger(slidEvent);
}
if (isCycling) {
this.cycle();
}
}; // Static
Carousel._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = _extends({}, Default, $$$1(this).data());
if (typeof config === 'object') {
_config = _extends({}, _config, config);
}
var action = typeof config === 'string' ? config : _config.slide;
if (!data) {
data = new Carousel(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'number') {
data.to(config);
} else if (typeof action === 'string') {
if (typeof data[action] === 'undefined') {
throw new TypeError("No method named \"" + action + "\"");
}
data[action]();
} else if (_config.interval) {
data.pause();
data.cycle();
}
});
};
Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
var selector = Util.getSelectorFromElement(this);
if (!selector) {
return;
}
var target = $$$1(selector)[0];
if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
return;
}
var config = _extends({}, $$$1(target).data(), $$$1(this).data());
var slideIndex = this.getAttribute('data-slide-to');
if (slideIndex) {
config.interval = false;
}
Carousel._jQueryInterface.call($$$1(target), config);
if (slideIndex) {
$$$1(target).data(DATA_KEY).to(slideIndex);
}
event.preventDefault();
};
_createClass(Carousel, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}]);
return Carousel;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
$$$1(window).on(Event.LOAD_DATA_API, function () {
$$$1(Selector.DATA_RIDE).each(function () {
var $carousel = $$$1(this);
Carousel._jQueryInterface.call($carousel, $carousel.data());
});
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Carousel._jQueryInterface;
$$$1.fn[NAME].Constructor = Carousel;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Carousel._jQueryInterface;
};
return Carousel;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): collapse.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Collapse = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'collapse';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.collapse';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var TRANSITION_DURATION = 600;
var Default = {
toggle: true,
parent: ''
};
var DefaultType = {
toggle: 'boolean',
parent: '(string|element)'
};
var Event = {
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
SHOW: 'show',
COLLAPSE: 'collapse',
COLLAPSING: 'collapsing',
COLLAPSED: 'collapsed'
};
var Dimension = {
WIDTH: 'width',
HEIGHT: 'height'
};
var Selector = {
ACTIVES: '.show, .collapsing',
DATA_TOGGLE: '[data-toggle="collapse"]'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Collapse =
/*#__PURE__*/
function () {
function Collapse(element, config) {
this._isTransitioning = false;
this._element = element;
this._config = this._getConfig(config);
this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
var tabToggles = $$$1(Selector.DATA_TOGGLE);
for (var i = 0; i < tabToggles.length; i++) {
var elem = tabToggles[i];
var selector = Util.getSelectorFromElement(elem);
if (selector !== null && $$$1(selector).filter(element).length > 0) {
this._selector = selector;
this._triggerArray.push(elem);
}
}
this._parent = this._config.parent ? this._getParent() : null;
if (!this._config.parent) {
this._addAriaAndCollapsedClass(this._element, this._triggerArray);
}
if (this._config.toggle) {
this.toggle();
}
} // Getters
var _proto = Collapse.prototype;
// Public
_proto.toggle = function toggle() {
if ($$$1(this._element).hasClass(ClassName.SHOW)) {
this.hide();
} else {
this.show();
}
};
_proto.show = function show() {
var _this = this;
if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
return;
}
var actives;
var activesData;
if (this._parent) {
actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
if (actives.length === 0) {
actives = null;
}
}
if (actives) {
activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
if (activesData && activesData._isTransitioning) {
return;
}
}
var startEvent = $$$1.Event(Event.SHOW);
$$$1(this._element).trigger(startEvent);
if (startEvent.isDefaultPrevented()) {
return;
}
if (actives) {
Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
if (!activesData) {
$$$1(actives).data(DATA_KEY, null);
}
}
var dimension = this._getDimension();
$$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
this._element.style[dimension] = 0;
if (this._triggerArray.length > 0) {
$$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
}
this.setTransitioning(true);
var complete = function complete() {
$$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
_this._element.style[dimension] = '';
_this.setTransitioning(false);
$$$1(_this._element).trigger(Event.SHOWN);
};
if (!Util.supportsTransitionEnd()) {
complete();
return;
}
var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
var scrollSize = "scroll" + capitalizedDimension;
$$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
this._element.style[dimension] = this._element[scrollSize] + "px";
};
_proto.hide = function hide() {
var _this2 = this;
if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
return;
}
var startEvent = $$$1.Event(Event.HIDE);
$$$1(this._element).trigger(startEvent);
if (startEvent.isDefaultPrevented()) {
return;
}
var dimension = this._getDimension();
this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
Util.reflow(this._element);
$$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);
if (this._triggerArray.length > 0) {
for (var i = 0; i < this._triggerArray.length; i++) {
var trigger = this._triggerArray[i];
var selector = Util.getSelectorFromElement(trigger);
if (selector !== null) {
var $elem = $$$1(selector);
if (!$elem.hasClass(ClassName.SHOW)) {
$$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
}
}
}
}
this.setTransitioning(true);
var complete = function complete() {
_this2.setTransitioning(false);
$$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
};
this._element.style[dimension] = '';
if (!Util.supportsTransitionEnd()) {
complete();
return;
}
$$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
};
_proto.setTransitioning = function setTransitioning(isTransitioning) {
this._isTransitioning = isTransitioning;
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
this._config = null;
this._parent = null;
this._element = null;
this._triggerArray = null;
this._isTransitioning = null;
}; // Private
_proto._getConfig = function _getConfig(config) {
config = _extends({}, Default, config);
config.toggle = Boolean(config.toggle); // Coerce string values
Util.typeCheckConfig(NAME, config, DefaultType);
return config;
};
_proto._getDimension = function _getDimension() {
var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
};
_proto._getParent = function _getParent() {
var _this3 = this;
var parent = null;
if (Util.isElement(this._config.parent)) {
parent = this._config.parent; // It's a jQuery object
if (typeof this._config.parent.jquery !== 'undefined') {
parent = this._config.parent[0];
}
} else {
parent = $$$1(this._config.parent)[0];
}
var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
$$$1(parent).find(selector).each(function (i, element) {
_this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
});
return parent;
};
_proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
if (element) {
var isOpen = $$$1(element).hasClass(ClassName.SHOW);
if (triggerArray.length > 0) {
$$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
}
}
}; // Static
Collapse._getTargetFromElement = function _getTargetFromElement(element) {
var selector = Util.getSelectorFromElement(element);
return selector ? $$$1(selector)[0] : null;
};
Collapse._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var $this = $$$1(this);
var data = $this.data(DATA_KEY);
var _config = _extends({}, Default, $this.data(), typeof config === 'object' && config);
if (!data && _config.toggle && /show|hide/.test(config)) {
_config.toggle = false;
}
if (!data) {
data = new Collapse(this, _config);
$this.data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
_createClass(Collapse, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}]);
return Collapse;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
// preventDefault only for <a> elements (which change the URL) not inside the collapsible element
if (event.currentTarget.tagName === 'A') {
event.preventDefault();
}
var $trigger = $$$1(this);
var selector = Util.getSelectorFromElement(this);
$$$1(selector).each(function () {
var $target = $$$1(this);
var data = $target.data(DATA_KEY);
var config = data ? 'toggle' : $trigger.data();
Collapse._jQueryInterface.call($target, config);
});
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Collapse._jQueryInterface;
$$$1.fn[NAME].Constructor = Collapse;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Collapse._jQueryInterface;
};
return Collapse;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): dropdown.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Dropdown = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'dropdown';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.dropdown';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
var Event = {
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
CLICK: "click" + EVENT_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY,
KEYDOWN_DATA_API: "keydown" + EVENT_KEY + DATA_API_KEY,
KEYUP_DATA_API: "keyup" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
DISABLED: 'disabled',
SHOW: 'show',
DROPUP: 'dropup',
DROPRIGHT: 'dropright',
DROPLEFT: 'dropleft',
MENURIGHT: 'dropdown-menu-right',
MENULEFT: 'dropdown-menu-left',
POSITION_STATIC: 'position-static'
};
var Selector = {
DATA_TOGGLE: '[data-toggle="dropdown"]',
FORM_CHILD: '.dropdown form',
MENU: '.dropdown-menu',
NAVBAR_NAV: '.navbar-nav',
VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled)'
};
var AttachmentMap = {
TOP: 'top-start',
TOPEND: 'top-end',
BOTTOM: 'bottom-start',
BOTTOMEND: 'bottom-end',
RIGHT: 'right-start',
RIGHTEND: 'right-end',
LEFT: 'left-start',
LEFTEND: 'left-end'
};
var Default = {
offset: 0,
flip: true,
boundary: 'scrollParent',
reference: 'toggle',
display: 'dynamic'
};
var DefaultType = {
offset: '(number|string|function)',
flip: 'boolean',
boundary: '(string|element)',
reference: '(string|element)',
display: 'string'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Dropdown =
/*#__PURE__*/
function () {
function Dropdown(element, config) {
this._element = element;
this._popper = null;
this._config = this._getConfig(config);
this._menu = this._getMenuElement();
this._inNavbar = this._detectNavbar();
this._addEventListeners();
} // Getters
var _proto = Dropdown.prototype;
// Public
_proto.toggle = function toggle() {
if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
return;
}
var parent = Dropdown._getParentFromElement(this._element);
var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
Dropdown._clearMenus();
if (isActive) {
return;
}
var relatedTarget = {
relatedTarget: this._element
};
var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
$$$1(parent).trigger(showEvent);
if (showEvent.isDefaultPrevented()) {
return;
} // Disable totally Popper.js for Dropdown in Navbar
if (!this._inNavbar) {
/**
* Check for Popper dependency
* Popper - https://popper.js.org
*/
if (typeof Popper === 'undefined') {
throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
}
var referenceElement = this._element;
if (this._config.reference === 'parent') {
referenceElement = parent;
} else if (Util.isElement(this._config.reference)) {
referenceElement = this._config.reference; // Check if it's jQuery element
if (typeof this._config.reference.jquery !== 'undefined') {
referenceElement = this._config.reference[0];
}
} // If boundary is not `scrollParent`, then set position to `static`
// to allow the menu to "escape" the scroll parent's boundaries
// https://github.com/twbs/bootstrap/issues/24251
if (this._config.boundary !== 'scrollParent') {
$$$1(parent).addClass(ClassName.POSITION_STATIC);
}
this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig());
} // If this is a touch-enabled device we add extra
// empty mouseover listeners to the body's immediate children;
// only needed because of broken event delegation on iOS
// https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
$$$1(document.body).children().on('mouseover', null, $$$1.noop);
}
this._element.focus();
this._element.setAttribute('aria-expanded', true);
$$$1(this._menu).toggleClass(ClassName.SHOW);
$$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
$$$1(this._element).off(EVENT_KEY);
this._element = null;
this._menu = null;
if (this._popper !== null) {
this._popper.destroy();
this._popper = null;
}
};
_proto.update = function update() {
this._inNavbar = this._detectNavbar();
if (this._popper !== null) {
this._popper.scheduleUpdate();
}
}; // Private
_proto._addEventListeners = function _addEventListeners() {
var _this = this;
$$$1(this._element).on(Event.CLICK, function (event) {
event.preventDefault();
event.stopPropagation();
_this.toggle();
});
};
_proto._getConfig = function _getConfig(config) {
config = _extends({}, this.constructor.Default, $$$1(this._element).data(), config);
Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
return config;
};
_proto._getMenuElement = function _getMenuElement() {
if (!this._menu) {
var parent = Dropdown._getParentFromElement(this._element);
this._menu = $$$1(parent).find(Selector.MENU)[0];
}
return this._menu;
};
_proto._getPlacement = function _getPlacement() {
var $parentDropdown = $$$1(this._element).parent();
var placement = AttachmentMap.BOTTOM; // Handle dropup
if ($parentDropdown.hasClass(ClassName.DROPUP)) {
placement = AttachmentMap.TOP;
if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
placement = AttachmentMap.TOPEND;
}
} else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
placement = AttachmentMap.RIGHT;
} else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
placement = AttachmentMap.LEFT;
} else if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
placement = AttachmentMap.BOTTOMEND;
}
return placement;
};
_proto._detectNavbar = function _detectNavbar() {
return $$$1(this._element).closest('.navbar').length > 0;
};
_proto._getPopperConfig = function _getPopperConfig() {
var _this2 = this;
var offsetConf = {};
if (typeof this._config.offset === 'function') {
offsetConf.fn = function (data) {
data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets) || {});
return data;
};
} else {
offsetConf.offset = this._config.offset;
}
var popperConfig = {
placement: this._getPlacement(),
modifiers: {
offset: offsetConf,
flip: {
enabled: this._config.flip
},
preventOverflow: {
boundariesElement: this._config.boundary
}
} // Disable Popper.js if we have a static display
};
if (this._config.display === 'static') {
popperConfig.modifiers.applyStyle = {
enabled: false
};
}
return popperConfig;
}; // Static
Dropdown._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = typeof config === 'object' ? config : null;
if (!data) {
data = new Dropdown(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
Dropdown._clearMenus = function _clearMenus(event) {
if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
return;
}
var toggles = $$$1.makeArray($$$1(Selector.DATA_TOGGLE));
for (var i = 0; i < toggles.length; i++) {
var parent = Dropdown._getParentFromElement(toggles[i]);
var context = $$$1(toggles[i]).data(DATA_KEY);
var relatedTarget = {
relatedTarget: toggles[i]
};
if (!context) {
continue;
}
var dropdownMenu = context._menu;
if (!$$$1(parent).hasClass(ClassName.SHOW)) {
continue;
}
if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
continue;
}
var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
$$$1(parent).trigger(hideEvent);
if (hideEvent.isDefaultPrevented()) {
continue;
} // If this is a touch-enabled device we remove the extra
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
$$$1(document.body).children().off('mouseover', null, $$$1.noop);
}
toggles[i].setAttribute('aria-expanded', 'false');
$$$1(dropdownMenu).removeClass(ClassName.SHOW);
$$$1(parent).removeClass(ClassName.SHOW).trigger($$$1.Event(Event.HIDDEN, relatedTarget));
}
};
Dropdown._getParentFromElement = function _getParentFromElement(element) {
var parent;
var selector = Util.getSelectorFromElement(element);
if (selector) {
parent = $$$1(selector)[0];
}
return parent || element.parentNode;
}; // eslint-disable-next-line complexity
Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
// If not input/textarea:
// - And not a key in REGEXP_KEYDOWN => not a dropdown command
// If input/textarea:
// - If space key => not a dropdown command
// - If key is other than escape
// - If key is not up or down => not a dropdown command
// - If trigger inside the menu => not a dropdown command
if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $$$1(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
return;
}
event.preventDefault();
event.stopPropagation();
if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
return;
}
var parent = Dropdown._getParentFromElement(this);
var isActive = $$$1(parent).hasClass(ClassName.SHOW);
if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
if (event.which === ESCAPE_KEYCODE) {
var toggle = $$$1(parent).find(Selector.DATA_TOGGLE)[0];
$$$1(toggle).trigger('focus');
}
$$$1(this).trigger('click');
return;
}
var items = $$$1(parent).find(Selector.VISIBLE_ITEMS).get();
if (items.length === 0) {
return;
}
var index = items.indexOf(event.target);
if (event.which === ARROW_UP_KEYCODE && index > 0) {
// Up
index--;
}
if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
// Down
index++;
}
if (index < 0) {
index = 0;
}
items[index].focus();
};
_createClass(Dropdown, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}, {
key: "DefaultType",
get: function get() {
return DefaultType;
}
}]);
return Dropdown;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA_API + " " + Event.KEYUP_DATA_API, Dropdown._clearMenus).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
event.preventDefault();
event.stopPropagation();
Dropdown._jQueryInterface.call($$$1(this), 'toggle');
}).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) {
e.stopPropagation();
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Dropdown._jQueryInterface;
$$$1.fn[NAME].Constructor = Dropdown;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Dropdown._jQueryInterface;
};
return Dropdown;
}($, Popper);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): modal.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Modal = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'modal';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.modal';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var TRANSITION_DURATION = 300;
var BACKDROP_TRANSITION_DURATION = 150;
var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
var Default = {
backdrop: true,
keyboard: true,
focus: true,
show: true
};
var DefaultType = {
backdrop: '(boolean|string)',
keyboard: 'boolean',
focus: 'boolean',
show: 'boolean'
};
var Event = {
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
FOCUSIN: "focusin" + EVENT_KEY,
RESIZE: "resize" + EVENT_KEY,
CLICK_DISMISS: "click.dismiss" + EVENT_KEY,
KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY,
MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY,
MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
BACKDROP: 'modal-backdrop',
OPEN: 'modal-open',
FADE: 'fade',
SHOW: 'show'
};
var Selector = {
DIALOG: '.modal-dialog',
DATA_TOGGLE: '[data-toggle="modal"]',
DATA_DISMISS: '[data-dismiss="modal"]',
FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
STICKY_CONTENT: '.sticky-top',
NAVBAR_TOGGLER: '.navbar-toggler'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Modal =
/*#__PURE__*/
function () {
function Modal(element, config) {
this._config = this._getConfig(config);
this._element = element;
this._dialog = $$$1(element).find(Selector.DIALOG)[0];
this._backdrop = null;
this._isShown = false;
this._isBodyOverflowing = false;
this._ignoreBackdropClick = false;
this._scrollbarWidth = 0;
} // Getters
var _proto = Modal.prototype;
// Public
_proto.toggle = function toggle(relatedTarget) {
return this._isShown ? this.hide() : this.show(relatedTarget);
};
_proto.show = function show(relatedTarget) {
var _this = this;
if (this._isTransitioning || this._isShown) {
return;
}
if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
this._isTransitioning = true;
}
var showEvent = $$$1.Event(Event.SHOW, {
relatedTarget: relatedTarget
});
$$$1(this._element).trigger(showEvent);
if (this._isShown || showEvent.isDefaultPrevented()) {
return;
}
this._isShown = true;
this._checkScrollbar();
this._setScrollbar();
this._adjustDialog();
$$$1(document.body).addClass(ClassName.OPEN);
this._setEscapeEvent();
this._setResizeEvent();
$$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function (event) {
return _this.hide(event);
});
$$$1(this._dialog).on(Event.MOUSEDOWN_DISMISS, function () {
$$$1(_this._element).one(Event.MOUSEUP_DISMISS, function (event) {
if ($$$1(event.target).is(_this._element)) {
_this._ignoreBackdropClick = true;
}
});
});
this._showBackdrop(function () {
return _this._showElement(relatedTarget);
});
};
_proto.hide = function hide(event) {
var _this2 = this;
if (event) {
event.preventDefault();
}
if (this._isTransitioning || !this._isShown) {
return;
}
var hideEvent = $$$1.Event(Event.HIDE);
$$$1(this._element).trigger(hideEvent);
if (!this._isShown || hideEvent.isDefaultPrevented()) {
return;
}
this._isShown = false;
var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
if (transition) {
this._isTransitioning = true;
}
this._setEscapeEvent();
this._setResizeEvent();
$$$1(document).off(Event.FOCUSIN);
$$$1(this._element).removeClass(ClassName.SHOW);
$$$1(this._element).off(Event.CLICK_DISMISS);
$$$1(this._dialog).off(Event.MOUSEDOWN_DISMISS);
if (transition) {
$$$1(this._element).one(Util.TRANSITION_END, function (event) {
return _this2._hideModal(event);
}).emulateTransitionEnd(TRANSITION_DURATION);
} else {
this._hideModal();
}
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
$$$1(window, document, this._element, this._backdrop).off(EVENT_KEY);
this._config = null;
this._element = null;
this._dialog = null;
this._backdrop = null;
this._isShown = null;
this._isBodyOverflowing = null;
this._ignoreBackdropClick = null;
this._scrollbarWidth = null;
};
_proto.handleUpdate = function handleUpdate() {
this._adjustDialog();
}; // Private
_proto._getConfig = function _getConfig(config) {
config = _extends({}, Default, config);
Util.typeCheckConfig(NAME, config, DefaultType);
return config;
};
_proto._showElement = function _showElement(relatedTarget) {
var _this3 = this;
var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
// Don't move modal's DOM position
document.body.appendChild(this._element);
}
this._element.style.display = 'block';
this._element.removeAttribute('aria-hidden');
this._element.scrollTop = 0;
if (transition) {
Util.reflow(this._element);
}
$$$1(this._element).addClass(ClassName.SHOW);
if (this._config.focus) {
this._enforceFocus();
}
var shownEvent = $$$1.Event(Event.SHOWN, {
relatedTarget: relatedTarget
});
var transitionComplete = function transitionComplete() {
if (_this3._config.focus) {
_this3._element.focus();
}
_this3._isTransitioning = false;
$$$1(_this3._element).trigger(shownEvent);
};
if (transition) {
$$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(TRANSITION_DURATION);
} else {
transitionComplete();
}
};
_proto._enforceFocus = function _enforceFocus() {
var _this4 = this;
$$$1(document).off(Event.FOCUSIN) // Guard against infinite focus loop
.on(Event.FOCUSIN, function (event) {
if (document !== event.target && _this4._element !== event.target && $$$1(_this4._element).has(event.target).length === 0) {
_this4._element.focus();
}
});
};
_proto._setEscapeEvent = function _setEscapeEvent() {
var _this5 = this;
if (this._isShown && this._config.keyboard) {
$$$1(this._element).on(Event.KEYDOWN_DISMISS, function (event) {
if (event.which === ESCAPE_KEYCODE) {
event.preventDefault();
_this5.hide();
}
});
} else if (!this._isShown) {
$$$1(this._element).off(Event.KEYDOWN_DISMISS);
}
};
_proto._setResizeEvent = function _setResizeEvent() {
var _this6 = this;
if (this._isShown) {
$$$1(window).on(Event.RESIZE, function (event) {
return _this6.handleUpdate(event);
});
} else {
$$$1(window).off(Event.RESIZE);
}
};
_proto._hideModal = function _hideModal() {
var _this7 = this;
this._element.style.display = 'none';
this._element.setAttribute('aria-hidden', true);
this._isTransitioning = false;
this._showBackdrop(function () {
$$$1(document.body).removeClass(ClassName.OPEN);
_this7._resetAdjustments();
_this7._resetScrollbar();
$$$1(_this7._element).trigger(Event.HIDDEN);
});
};
_proto._removeBackdrop = function _removeBackdrop() {
if (this._backdrop) {
$$$1(this._backdrop).remove();
this._backdrop = null;
}
};
_proto._showBackdrop = function _showBackdrop(callback) {
var _this8 = this;
var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
if (this._isShown && this._config.backdrop) {
var doAnimate = Util.supportsTransitionEnd() && animate;
this._backdrop = document.createElement('div');
this._backdrop.className = ClassName.BACKDROP;
if (animate) {
$$$1(this._backdrop).addClass(animate);
}
$$$1(this._backdrop).appendTo(document.body);
$$$1(this._element).on(Event.CLICK_DISMISS, function (event) {
if (_this8._ignoreBackdropClick) {
_this8._ignoreBackdropClick = false;
return;
}
if (event.target !== event.currentTarget) {
return;
}
if (_this8._config.backdrop === 'static') {
_this8._element.focus();
} else {
_this8.hide();
}
});
if (doAnimate) {
Util.reflow(this._backdrop);
}
$$$1(this._backdrop).addClass(ClassName.SHOW);
if (!callback) {
return;
}
if (!doAnimate) {
callback();
return;
}
$$$1(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
} else if (!this._isShown && this._backdrop) {
$$$1(this._backdrop).removeClass(ClassName.SHOW);
var callbackRemove = function callbackRemove() {
_this8._removeBackdrop();
if (callback) {
callback();
}
};
if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
$$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
} else {
callbackRemove();
}
} else if (callback) {
callback();
}
}; // ----------------------------------------------------------------------
// the following methods are used to handle overflowing modals
// todo (fat): these should probably be refactored out of modal.js
// ----------------------------------------------------------------------
_proto._adjustDialog = function _adjustDialog() {
var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
if (!this._isBodyOverflowing && isModalOverflowing) {
this._element.style.paddingLeft = this._scrollbarWidth + "px";
}
if (this._isBodyOverflowing && !isModalOverflowing) {
this._element.style.paddingRight = this._scrollbarWidth + "px";
}
};
_proto._resetAdjustments = function _resetAdjustments() {
this._element.style.paddingLeft = '';
this._element.style.paddingRight = '';
};
_proto._checkScrollbar = function _checkScrollbar() {
var rect = document.body.getBoundingClientRect();
this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
this._scrollbarWidth = this._getScrollbarWidth();
};
_proto._setScrollbar = function _setScrollbar() {
var _this9 = this;
if (this._isBodyOverflowing) {
// Note: DOMNode.style.paddingRight returns the actual value or '' if not set
// while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
// Adjust fixed content padding
$$$1(Selector.FIXED_CONTENT).each(function (index, element) {
var actualPadding = $$$1(element)[0].style.paddingRight;
var calculatedPadding = $$$1(element).css('padding-right');
$$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
}); // Adjust sticky content margin
$$$1(Selector.STICKY_CONTENT).each(function (index, element) {
var actualMargin = $$$1(element)[0].style.marginRight;
var calculatedMargin = $$$1(element).css('margin-right');
$$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
}); // Adjust navbar-toggler margin
$$$1(Selector.NAVBAR_TOGGLER).each(function (index, element) {
var actualMargin = $$$1(element)[0].style.marginRight;
var calculatedMargin = $$$1(element).css('margin-right');
$$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) + _this9._scrollbarWidth + "px");
}); // Adjust body padding
var actualPadding = document.body.style.paddingRight;
var calculatedPadding = $$$1(document.body).css('padding-right');
$$$1(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
}
};
_proto._resetScrollbar = function _resetScrollbar() {
// Restore fixed content padding
$$$1(Selector.FIXED_CONTENT).each(function (index, element) {
var padding = $$$1(element).data('padding-right');
if (typeof padding !== 'undefined') {
$$$1(element).css('padding-right', padding).removeData('padding-right');
}
}); // Restore sticky content and navbar-toggler margin
$$$1(Selector.STICKY_CONTENT + ", " + Selector.NAVBAR_TOGGLER).each(function (index, element) {
var margin = $$$1(element).data('margin-right');
if (typeof margin !== 'undefined') {
$$$1(element).css('margin-right', margin).removeData('margin-right');
}
}); // Restore body padding
var padding = $$$1(document.body).data('padding-right');
if (typeof padding !== 'undefined') {
$$$1(document.body).css('padding-right', padding).removeData('padding-right');
}
};
_proto._getScrollbarWidth = function _getScrollbarWidth() {
// thx d.walsh
var scrollDiv = document.createElement('div');
scrollDiv.className = ClassName.SCROLLBAR_MEASURER;
document.body.appendChild(scrollDiv);
var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
document.body.removeChild(scrollDiv);
return scrollbarWidth;
}; // Static
Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = _extends({}, Modal.Default, $$$1(this).data(), typeof config === 'object' && config);
if (!data) {
data = new Modal(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config](relatedTarget);
} else if (_config.show) {
data.show(relatedTarget);
}
});
};
_createClass(Modal, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}]);
return Modal;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
var _this10 = this;
var target;
var selector = Util.getSelectorFromElement(this);
if (selector) {
target = $$$1(selector)[0];
}
var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _extends({}, $$$1(target).data(), $$$1(this).data());
if (this.tagName === 'A' || this.tagName === 'AREA') {
event.preventDefault();
}
var $target = $$$1(target).one(Event.SHOW, function (showEvent) {
if (showEvent.isDefaultPrevented()) {
// Only register focus restorer if modal will actually get shown
return;
}
$target.one(Event.HIDDEN, function () {
if ($$$1(_this10).is(':visible')) {
_this10.focus();
}
});
});
Modal._jQueryInterface.call($$$1(target), config, this);
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Modal._jQueryInterface;
$$$1.fn[NAME].Constructor = Modal;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Modal._jQueryInterface;
};
return Modal;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): tooltip.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Tooltip = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'tooltip';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.tooltip';
var EVENT_KEY = "." + DATA_KEY;
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var TRANSITION_DURATION = 150;
var CLASS_PREFIX = 'bs-tooltip';
var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
var DefaultType = {
animation: 'boolean',
template: 'string',
title: '(string|element|function)',
trigger: 'string',
delay: '(number|object)',
html: 'boolean',
selector: '(string|boolean)',
placement: '(string|function)',
offset: '(number|string)',
container: '(string|element|boolean)',
fallbackPlacement: '(string|array)',
boundary: '(string|element)'
};
var AttachmentMap = {
AUTO: 'auto',
TOP: 'top',
RIGHT: 'right',
BOTTOM: 'bottom',
LEFT: 'left'
};
var Default = {
animation: true,
template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
trigger: 'hover focus',
title: '',
delay: 0,
html: false,
selector: false,
placement: 'top',
offset: 0,
container: false,
fallbackPlacement: 'flip',
boundary: 'scrollParent'
};
var HoverState = {
SHOW: 'show',
OUT: 'out'
};
var Event = {
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
INSERTED: "inserted" + EVENT_KEY,
CLICK: "click" + EVENT_KEY,
FOCUSIN: "focusin" + EVENT_KEY,
FOCUSOUT: "focusout" + EVENT_KEY,
MOUSEENTER: "mouseenter" + EVENT_KEY,
MOUSELEAVE: "mouseleave" + EVENT_KEY
};
var ClassName = {
FADE: 'fade',
SHOW: 'show'
};
var Selector = {
TOOLTIP: '.tooltip',
TOOLTIP_INNER: '.tooltip-inner',
ARROW: '.arrow'
};
var Trigger = {
HOVER: 'hover',
FOCUS: 'focus',
CLICK: 'click',
MANUAL: 'manual'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Tooltip =
/*#__PURE__*/
function () {
function Tooltip(element, config) {
/**
* Check for Popper dependency
* Popper - https://popper.js.org
*/
if (typeof Popper === 'undefined') {
throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
} // private
this._isEnabled = true;
this._timeout = 0;
this._hoverState = '';
this._activeTrigger = {};
this._popper = null; // Protected
this.element = element;
this.config = this._getConfig(config);
this.tip = null;
this._setListeners();
} // Getters
var _proto = Tooltip.prototype;
// Public
_proto.enable = function enable() {
this._isEnabled = true;
};
_proto.disable = function disable() {
this._isEnabled = false;
};
_proto.toggleEnabled = function toggleEnabled() {
this._isEnabled = !this._isEnabled;
};
_proto.toggle = function toggle(event) {
if (!this._isEnabled) {
return;
}
if (event) {
var dataKey = this.constructor.DATA_KEY;
var context = $$$1(event.currentTarget).data(dataKey);
if (!context) {
context = new this.constructor(event.currentTarget, this._getDelegateConfig());
$$$1(event.currentTarget).data(dataKey, context);
}
context._activeTrigger.click = !context._activeTrigger.click;
if (context._isWithActiveTrigger()) {
context._enter(null, context);
} else {
context._leave(null, context);
}
} else {
if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
this._leave(null, this);
return;
}
this._enter(null, this);
}
};
_proto.dispose = function dispose() {
clearTimeout(this._timeout);
$$$1.removeData(this.element, this.constructor.DATA_KEY);
$$$1(this.element).off(this.constructor.EVENT_KEY);
$$$1(this.element).closest('.modal').off('hide.bs.modal');
if (this.tip) {
$$$1(this.tip).remove();
}
this._isEnabled = null;
this._timeout = null;
this._hoverState = null;
this._activeTrigger = null;
if (this._popper !== null) {
this._popper.destroy();
}
this._popper = null;
this.element = null;
this.config = null;
this.tip = null;
};
_proto.show = function show() {
var _this = this;
if ($$$1(this.element).css('display') === 'none') {
throw new Error('Please use show on visible elements');
}
var showEvent = $$$1.Event(this.constructor.Event.SHOW);
if (this.isWithContent() && this._isEnabled) {
$$$1(this.element).trigger(showEvent);
var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
if (showEvent.isDefaultPrevented() || !isInTheDom) {
return;
}
var tip = this.getTipElement();
var tipId = Util.getUID(this.constructor.NAME);
tip.setAttribute('id', tipId);
this.element.setAttribute('aria-describedby', tipId);
this.setContent();
if (this.config.animation) {
$$$1(tip).addClass(ClassName.FADE);
}
var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
var attachment = this._getAttachment(placement);
this.addAttachmentClass(attachment);
var container = this.config.container === false ? document.body : $$$1(this.config.container);
$$$1(tip).data(this.constructor.DATA_KEY, this);
if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
$$$1(tip).appendTo(container);
}
$$$1(this.element).trigger(this.constructor.Event.INSERTED);
this._popper = new Popper(this.element, tip, {
placement: attachment,
modifiers: {
offset: {
offset: this.config.offset
},
flip: {
behavior: this.config.fallbackPlacement
},
arrow: {
element: Selector.ARROW
},
preventOverflow: {
boundariesElement: this.config.boundary
}
},
onCreate: function onCreate(data) {
if (data.originalPlacement !== data.placement) {
_this._handlePopperPlacementChange(data);
}
},
onUpdate: function onUpdate(data) {
_this._handlePopperPlacementChange(data);
}
});
$$$1(tip).addClass(ClassName.SHOW); // If this is a touch-enabled device we add extra
// empty mouseover listeners to the body's immediate children;
// only needed because of broken event delegation on iOS
// https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
if ('ontouchstart' in document.documentElement) {
$$$1(document.body).children().on('mouseover', null, $$$1.noop);
}
var complete = function complete() {
if (_this.config.animation) {
_this._fixTransition();
}
var prevHoverState = _this._hoverState;
_this._hoverState = null;
$$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
if (prevHoverState === HoverState.OUT) {
_this._leave(null, _this);
}
};
if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
$$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION);
} else {
complete();
}
}
};
_proto.hide = function hide(callback) {
var _this2 = this;
var tip = this.getTipElement();
var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
var complete = function complete() {
if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
tip.parentNode.removeChild(tip);
}
_this2._cleanTipClass();
_this2.element.removeAttribute('aria-describedby');
$$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
if (_this2._popper !== null) {
_this2._popper.destroy();
}
if (callback) {
callback();
}
};
$$$1(this.element).trigger(hideEvent);
if (hideEvent.isDefaultPrevented()) {
return;
}
$$$1(tip).removeClass(ClassName.SHOW); // If this is a touch-enabled device we remove the extra
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
$$$1(document.body).children().off('mouseover', null, $$$1.noop);
}
this._activeTrigger[Trigger.CLICK] = false;
this._activeTrigger[Trigger.FOCUS] = false;
this._activeTrigger[Trigger.HOVER] = false;
if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
$$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
} else {
complete();
}
this._hoverState = '';
};
_proto.update = function update() {
if (this._popper !== null) {
this._popper.scheduleUpdate();
}
}; // Protected
_proto.isWithContent = function isWithContent() {
return Boolean(this.getTitle());
};
_proto.addAttachmentClass = function addAttachmentClass(attachment) {
$$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
};
_proto.getTipElement = function getTipElement() {
this.tip = this.tip || $$$1(this.config.template)[0];
return this.tip;
};
_proto.setContent = function setContent() {
var $tip = $$$1(this.getTipElement());
this.setElementContent($tip.find(Selector.TOOLTIP_INNER), this.getTitle());
$tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
};
_proto.setElementContent = function setElementContent($element, content) {
var html = this.config.html;
if (typeof content === 'object' && (content.nodeType || content.jquery)) {
// Content is a DOM node or a jQuery
if (html) {
if (!$$$1(content).parent().is($element)) {
$element.empty().append(content);
}
} else {
$element.text($$$1(content).text());
}
} else {
$element[html ? 'html' : 'text'](content);
}
};
_proto.getTitle = function getTitle() {
var title = this.element.getAttribute('data-original-title');
if (!title) {
title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
}
return title;
}; // Private
_proto._getAttachment = function _getAttachment(placement) {
return AttachmentMap[placement.toUpperCase()];
};
_proto._setListeners = function _setListeners() {
var _this3 = this;
var triggers = this.config.trigger.split(' ');
triggers.forEach(function (trigger) {
if (trigger === 'click') {
$$$1(_this3.element).on(_this3.constructor.Event.CLICK, _this3.config.selector, function (event) {
return _this3.toggle(event);
});
} else if (trigger !== Trigger.MANUAL) {
var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
$$$1(_this3.element).on(eventIn, _this3.config.selector, function (event) {
return _this3._enter(event);
}).on(eventOut, _this3.config.selector, function (event) {
return _this3._leave(event);
});
}
$$$1(_this3.element).closest('.modal').on('hide.bs.modal', function () {
return _this3.hide();
});
});
if (this.config.selector) {
this.config = _extends({}, this.config, {
trigger: 'manual',
selector: ''
});
} else {
this._fixTitle();
}
};
_proto._fixTitle = function _fixTitle() {
var titleType = typeof this.element.getAttribute('data-original-title');
if (this.element.getAttribute('title') || titleType !== 'string') {
this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
this.element.setAttribute('title', '');
}
};
_proto._enter = function _enter(event, context) {
var dataKey = this.constructor.DATA_KEY;
context = context || $$$1(event.currentTarget).data(dataKey);
if (!context) {
context = new this.constructor(event.currentTarget, this._getDelegateConfig());
$$$1(event.currentTarget).data(dataKey, context);
}
if (event) {
context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
}
if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
context._hoverState = HoverState.SHOW;
return;
}
clearTimeout(context._timeout);
context._hoverState = HoverState.SHOW;
if (!context.config.delay || !context.config.delay.show) {
context.show();
return;
}
context._timeout = setTimeout(function () {
if (context._hoverState === HoverState.SHOW) {
context.show();
}
}, context.config.delay.show);
};
_proto._leave = function _leave(event, context) {
var dataKey = this.constructor.DATA_KEY;
context = context || $$$1(event.currentTarget).data(dataKey);
if (!context) {
context = new this.constructor(event.currentTarget, this._getDelegateConfig());
$$$1(event.currentTarget).data(dataKey, context);
}
if (event) {
context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
}
if (context._isWithActiveTrigger()) {
return;
}
clearTimeout(context._timeout);
context._hoverState = HoverState.OUT;
if (!context.config.delay || !context.config.delay.hide) {
context.hide();
return;
}
context._timeout = setTimeout(function () {
if (context._hoverState === HoverState.OUT) {
context.hide();
}
}, context.config.delay.hide);
};
_proto._isWithActiveTrigger = function _isWithActiveTrigger() {
for (var trigger in this._activeTrigger) {
if (this._activeTrigger[trigger]) {
return true;
}
}
return false;
};
_proto._getConfig = function _getConfig(config) {
config = _extends({}, this.constructor.Default, $$$1(this.element).data(), config);
if (typeof config.delay === 'number') {
config.delay = {
show: config.delay,
hide: config.delay
};
}
if (typeof config.title === 'number') {
config.title = config.title.toString();
}
if (typeof config.content === 'number') {
config.content = config.content.toString();
}
Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
return config;
};
_proto._getDelegateConfig = function _getDelegateConfig() {
var config = {};
if (this.config) {
for (var key in this.config) {
if (this.constructor.Default[key] !== this.config[key]) {
config[key] = this.config[key];
}
}
}
return config;
};
_proto._cleanTipClass = function _cleanTipClass() {
var $tip = $$$1(this.getTipElement());
var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
if (tabClass !== null && tabClass.length > 0) {
$tip.removeClass(tabClass.join(''));
}
};
_proto._handlePopperPlacementChange = function _handlePopperPlacementChange(data) {
this._cleanTipClass();
this.addAttachmentClass(this._getAttachment(data.placement));
};
_proto._fixTransition = function _fixTransition() {
var tip = this.getTipElement();
var initConfigAnimation = this.config.animation;
if (tip.getAttribute('x-placement') !== null) {
return;
}
$$$1(tip).removeClass(ClassName.FADE);
this.config.animation = false;
this.hide();
this.show();
this.config.animation = initConfigAnimation;
}; // Static
Tooltip._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = typeof config === 'object' && config;
if (!data && /dispose|hide/.test(config)) {
return;
}
if (!data) {
data = new Tooltip(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
_createClass(Tooltip, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}, {
key: "NAME",
get: function get() {
return NAME;
}
}, {
key: "DATA_KEY",
get: function get() {
return DATA_KEY;
}
}, {
key: "Event",
get: function get() {
return Event;
}
}, {
key: "EVENT_KEY",
get: function get() {
return EVENT_KEY;
}
}, {
key: "DefaultType",
get: function get() {
return DefaultType;
}
}]);
return Tooltip;
}();
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Tooltip._jQueryInterface;
$$$1.fn[NAME].Constructor = Tooltip;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Tooltip._jQueryInterface;
};
return Tooltip;
}($, Popper);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): popover.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Popover = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'popover';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.popover';
var EVENT_KEY = "." + DATA_KEY;
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var CLASS_PREFIX = 'bs-popover';
var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
var Default = _extends({}, Tooltip.Default, {
placement: 'right',
trigger: 'click',
content: '',
template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
});
var DefaultType = _extends({}, Tooltip.DefaultType, {
content: '(string|element|function)'
});
var ClassName = {
FADE: 'fade',
SHOW: 'show'
};
var Selector = {
TITLE: '.popover-header',
CONTENT: '.popover-body'
};
var Event = {
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
INSERTED: "inserted" + EVENT_KEY,
CLICK: "click" + EVENT_KEY,
FOCUSIN: "focusin" + EVENT_KEY,
FOCUSOUT: "focusout" + EVENT_KEY,
MOUSEENTER: "mouseenter" + EVENT_KEY,
MOUSELEAVE: "mouseleave" + EVENT_KEY
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Popover =
/*#__PURE__*/
function (_Tooltip) {
_inheritsLoose(Popover, _Tooltip);
function Popover() {
return _Tooltip.apply(this, arguments) || this;
}
var _proto = Popover.prototype;
// Overrides
_proto.isWithContent = function isWithContent() {
return this.getTitle() || this._getContent();
};
_proto.addAttachmentClass = function addAttachmentClass(attachment) {
$$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
};
_proto.getTipElement = function getTipElement() {
this.tip = this.tip || $$$1(this.config.template)[0];
return this.tip;
};
_proto.setContent = function setContent() {
var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
var content = this._getContent();
if (typeof content === 'function') {
content = content.call(this.element);
}
this.setElementContent($tip.find(Selector.CONTENT), content);
$tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
}; // Private
_proto._getContent = function _getContent() {
return this.element.getAttribute('data-content') || this.config.content;
};
_proto._cleanTipClass = function _cleanTipClass() {
var $tip = $$$1(this.getTipElement());
var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
if (tabClass !== null && tabClass.length > 0) {
$tip.removeClass(tabClass.join(''));
}
}; // Static
Popover._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = typeof config === 'object' ? config : null;
if (!data && /destroy|hide/.test(config)) {
return;
}
if (!data) {
data = new Popover(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
_createClass(Popover, null, [{
key: "VERSION",
// Getters
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}, {
key: "NAME",
get: function get() {
return NAME;
}
}, {
key: "DATA_KEY",
get: function get() {
return DATA_KEY;
}
}, {
key: "Event",
get: function get() {
return Event;
}
}, {
key: "EVENT_KEY",
get: function get() {
return EVENT_KEY;
}
}, {
key: "DefaultType",
get: function get() {
return DefaultType;
}
}]);
return Popover;
}(Tooltip);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Popover._jQueryInterface;
$$$1.fn[NAME].Constructor = Popover;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Popover._jQueryInterface;
};
return Popover;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): scrollspy.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var ScrollSpy = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'scrollspy';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.scrollspy';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var Default = {
offset: 10,
method: 'auto',
target: ''
};
var DefaultType = {
offset: 'number',
method: 'string',
target: '(string|element)'
};
var Event = {
ACTIVATE: "activate" + EVENT_KEY,
SCROLL: "scroll" + EVENT_KEY,
LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
DROPDOWN_ITEM: 'dropdown-item',
DROPDOWN_MENU: 'dropdown-menu',
ACTIVE: 'active'
};
var Selector = {
DATA_SPY: '[data-spy="scroll"]',
ACTIVE: '.active',
NAV_LIST_GROUP: '.nav, .list-group',
NAV_LINKS: '.nav-link',
NAV_ITEMS: '.nav-item',
LIST_ITEMS: '.list-group-item',
DROPDOWN: '.dropdown',
DROPDOWN_ITEMS: '.dropdown-item',
DROPDOWN_TOGGLE: '.dropdown-toggle'
};
var OffsetMethod = {
OFFSET: 'offset',
POSITION: 'position'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var ScrollSpy =
/*#__PURE__*/
function () {
function ScrollSpy(element, config) {
var _this = this;
this._element = element;
this._scrollElement = element.tagName === 'BODY' ? window : element;
this._config = this._getConfig(config);
this._selector = this._config.target + " " + Selector.NAV_LINKS + "," + (this._config.target + " " + Selector.LIST_ITEMS + ",") + (this._config.target + " " + Selector.DROPDOWN_ITEMS);
this._offsets = [];
this._targets = [];
this._activeTarget = null;
this._scrollHeight = 0;
$$$1(this._scrollElement).on(Event.SCROLL, function (event) {
return _this._process(event);
});
this.refresh();
this._process();
} // Getters
var _proto = ScrollSpy.prototype;
// Public
_proto.refresh = function refresh() {
var _this2 = this;
var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
this._offsets = [];
this._targets = [];
this._scrollHeight = this._getScrollHeight();
var targets = $$$1.makeArray($$$1(this._selector));
targets.map(function (element) {
var target;
var targetSelector = Util.getSelectorFromElement(element);
if (targetSelector) {
target = $$$1(targetSelector)[0];
}
if (target) {
var targetBCR = target.getBoundingClientRect();
if (targetBCR.width || targetBCR.height) {
// TODO (fat): remove sketch reliance on jQuery position/offset
return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
}
}
return null;
}).filter(function (item) {
return item;
}).sort(function (a, b) {
return a[0] - b[0];
}).forEach(function (item) {
_this2._offsets.push(item[0]);
_this2._targets.push(item[1]);
});
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
$$$1(this._scrollElement).off(EVENT_KEY);
this._element = null;
this._scrollElement = null;
this._config = null;
this._selector = null;
this._offsets = null;
this._targets = null;
this._activeTarget = null;
this._scrollHeight = null;
}; // Private
_proto._getConfig = function _getConfig(config) {
config = _extends({}, Default, config);
if (typeof config.target !== 'string') {
var id = $$$1(config.target).attr('id');
if (!id) {
id = Util.getUID(NAME);
$$$1(config.target).attr('id', id);
}
config.target = "#" + id;
}
Util.typeCheckConfig(NAME, config, DefaultType);
return config;
};
_proto._getScrollTop = function _getScrollTop() {
return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
};
_proto._getScrollHeight = function _getScrollHeight() {
return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
};
_proto._getOffsetHeight = function _getOffsetHeight() {
return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
};
_proto._process = function _process() {
var scrollTop = this._getScrollTop() + this._config.offset;
var scrollHeight = this._getScrollHeight();
var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
if (this._scrollHeight !== scrollHeight) {
this.refresh();
}
if (scrollTop >= maxScroll) {
var target = this._targets[this._targets.length - 1];
if (this._activeTarget !== target) {
this._activate(target);
}
return;
}
if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
this._activeTarget = null;
this._clear();
return;
}
for (var i = this._offsets.length; i--;) {
var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
if (isActiveTarget) {
this._activate(this._targets[i]);
}
}
};
_proto._activate = function _activate(target) {
this._activeTarget = target;
this._clear();
var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style
queries = queries.map(function (selector) {
return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
});
var $link = $$$1(queries.join(','));
if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
$link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
$link.addClass(ClassName.ACTIVE);
} else {
// Set triggered link as active
$link.addClass(ClassName.ACTIVE); // Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
$link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_LINKS + ", " + Selector.LIST_ITEMS).addClass(ClassName.ACTIVE); // Handle special case when .nav-link is inside .nav-item
$link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE);
}
$$$1(this._scrollElement).trigger(Event.ACTIVATE, {
relatedTarget: target
});
};
_proto._clear = function _clear() {
$$$1(this._selector).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
}; // Static
ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var data = $$$1(this).data(DATA_KEY);
var _config = typeof config === 'object' && config;
if (!data) {
data = new ScrollSpy(this, _config);
$$$1(this).data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
_createClass(ScrollSpy, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}, {
key: "Default",
get: function get() {
return Default;
}
}]);
return ScrollSpy;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(window).on(Event.LOAD_DATA_API, function () {
var scrollSpys = $$$1.makeArray($$$1(Selector.DATA_SPY));
for (var i = scrollSpys.length; i--;) {
var $spy = $$$1(scrollSpys[i]);
ScrollSpy._jQueryInterface.call($spy, $spy.data());
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = ScrollSpy._jQueryInterface;
$$$1.fn[NAME].Constructor = ScrollSpy;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return ScrollSpy._jQueryInterface;
};
return ScrollSpy;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): tab.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
var Tab = function ($$$1) {
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
var NAME = 'tab';
var VERSION = '4.0.0';
var DATA_KEY = 'bs.tab';
var EVENT_KEY = "." + DATA_KEY;
var DATA_API_KEY = '.data-api';
var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
var TRANSITION_DURATION = 150;
var Event = {
HIDE: "hide" + EVENT_KEY,
HIDDEN: "hidden" + EVENT_KEY,
SHOW: "show" + EVENT_KEY,
SHOWN: "shown" + EVENT_KEY,
CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
};
var ClassName = {
DROPDOWN_MENU: 'dropdown-menu',
ACTIVE: 'active',
DISABLED: 'disabled',
FADE: 'fade',
SHOW: 'show'
};
var Selector = {
DROPDOWN: '.dropdown',
NAV_LIST_GROUP: '.nav, .list-group',
ACTIVE: '.active',
ACTIVE_UL: '> li > .active',
DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
DROPDOWN_TOGGLE: '.dropdown-toggle',
DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
};
var Tab =
/*#__PURE__*/
function () {
function Tab(element) {
this._element = element;
} // Getters
var _proto = Tab.prototype;
// Public
_proto.show = function show() {
var _this = this;
if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
return;
}
var target;
var previous;
var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0];
var selector = Util.getSelectorFromElement(this._element);
if (listElement) {
var itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE;
previous = $$$1.makeArray($$$1(listElement).find(itemSelector));
previous = previous[previous.length - 1];
}
var hideEvent = $$$1.Event(Event.HIDE, {
relatedTarget: this._element
});
var showEvent = $$$1.Event(Event.SHOW, {
relatedTarget: previous
});
if (previous) {
$$$1(previous).trigger(hideEvent);
}
$$$1(this._element).trigger(showEvent);
if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
return;
}
if (selector) {
target = $$$1(selector)[0];
}
this._activate(this._element, listElement);
var complete = function complete() {
var hiddenEvent = $$$1.Event(Event.HIDDEN, {
relatedTarget: _this._element
});
var shownEvent = $$$1.Event(Event.SHOWN, {
relatedTarget: previous
});
$$$1(previous).trigger(hiddenEvent);
$$$1(_this._element).trigger(shownEvent);
};
if (target) {
this._activate(target, target.parentNode, complete);
} else {
complete();
}
};
_proto.dispose = function dispose() {
$$$1.removeData(this._element, DATA_KEY);
this._element = null;
}; // Private
_proto._activate = function _activate(element, container, callback) {
var _this2 = this;
var activeElements;
if (container.nodeName === 'UL') {
activeElements = $$$1(container).find(Selector.ACTIVE_UL);
} else {
activeElements = $$$1(container).children(Selector.ACTIVE);
}
var active = activeElements[0];
var isTransitioning = callback && Util.supportsTransitionEnd() && active && $$$1(active).hasClass(ClassName.FADE);
var complete = function complete() {
return _this2._transitionComplete(element, active, callback);
};
if (active && isTransitioning) {
$$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
} else {
complete();
}
};
_proto._transitionComplete = function _transitionComplete(element, active, callback) {
if (active) {
$$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
if (dropdownChild) {
$$$1(dropdownChild).removeClass(ClassName.ACTIVE);
}
if (active.getAttribute('role') === 'tab') {
active.setAttribute('aria-selected', false);
}
}
$$$1(element).addClass(ClassName.ACTIVE);
if (element.getAttribute('role') === 'tab') {
element.setAttribute('aria-selected', true);
}
Util.reflow(element);
$$$1(element).addClass(ClassName.SHOW);
if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0];
if (dropdownElement) {
$$$1(dropdownElement).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
}
element.setAttribute('aria-expanded', true);
}
if (callback) {
callback();
}
}; // Static
Tab._jQueryInterface = function _jQueryInterface(config) {
return this.each(function () {
var $this = $$$1(this);
var data = $this.data(DATA_KEY);
if (!data) {
data = new Tab(this);
$this.data(DATA_KEY, data);
}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError("No method named \"" + config + "\"");
}
data[config]();
}
});
};
_createClass(Tab, null, [{
key: "VERSION",
get: function get() {
return VERSION;
}
}]);
return Tab;
}();
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
*/
$$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
event.preventDefault();
Tab._jQueryInterface.call($$$1(this), 'show');
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
$$$1.fn[NAME] = Tab._jQueryInterface;
$$$1.fn[NAME].Constructor = Tab;
$$$1.fn[NAME].noConflict = function () {
$$$1.fn[NAME] = JQUERY_NO_CONFLICT;
return Tab._jQueryInterface;
};
return Tab;
}($);
/**
* --------------------------------------------------------------------------
* Bootstrap (v4.0.0): index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* --------------------------------------------------------------------------
*/
(function ($$$1) {
if (typeof $$$1 === 'undefined') {
throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
}
var version = $$$1.fn.jquery.split(' ')[0].split('.');
var minMajor = 1;
var ltMajor = 2;
var minMinor = 9;
var minPatch = 1;
var maxMajor = 4;
if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
}
})($);
exports.Util = Util;
exports.Alert = Alert;
exports.Button = Button;
exports.Carousel = Carousel;
exports.Collapse = Collapse;
exports.Dropdown = Dropdown;
exports.Modal = Modal;
exports.Popover = Popover;
exports.Scrollspy = ScrollSpy;
exports.Tab = Tab;
exports.Tooltip = Tooltip;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=bootstrap.js.map
|
CKEDITOR.plugins.setLang("colorbutton","de",{auto:"Automatisch",bgColorTitle:"Hintergrundfarbe",colors:{"000":"Schwarz",8E5:"Kastanienbraun","8B4513":"Braun","2F4F4F":"Dunkles Schiefergrau","008080":"Blaugrün","000080":"Marineblau","4B0082":"Indigo",696969:"Dunkelgrau",B22222:"Ziegelrot",A52A2A:"Braun",DAA520:"Goldgelb","006400":"Dunkelgrün","40E0D0":"Türkis","0000CD":"Mittelblau",800080:"Lila",808080:"Grau",F00:"Rot",FF8C00:"Dunkelorange",FFD700:"Gold","008000":"Grün","0FF":"Cyan","00F":"Blau",EE82EE:"Violett",
A9A9A9:"Dunkelgrau",FFA07A:"Helles Lachsrosa",FFA500:"Orange",FFFF00:"Gelb","00FF00":"Lime",AFEEEE:"Blasstürkis",ADD8E6:"Hellblau",DDA0DD:"Pflaumenblau",D3D3D3:"Hellgrau",FFF0F5:"Lavendel",FAEBD7:"Antik Weiß",FFFFE0:"Hellgelb",F0FFF0:"Honigtau",F0FFFF:"Azurblau",F0F8FF:"Alice Blau",E6E6FA:"Lavendel",FFF:"Weiß"},more:"Weitere Farben...",panelTitle:"Farben",textColorTitle:"Textfarbe"});
|
import React from "react"
import PropTypes from "prop-types"
import { connect } from "react-redux"
import JobLink from "../JobLink/JobLink"
import TableHelper from "../TableHelper/TableHelper"
import RawJson from "../RawJson/RawJson"
const taskHeaders = ["ID", "Name", "Group", "Driver", "CPU", "Memory", "Disk"]
const JobTasks = ({ job, location }) => {
const tasks = []
job.TaskGroups.forEach(taskGroup => {
taskGroup.Tasks.forEach(task => {
tasks.push(
<tr key={task.ID}>
<td>
<JobLink jobId={job.ID} taskId={task.ID} taskGroupId={taskGroup.ID} />
</td>
<td>
{task.Name}
</td>
<td>
<JobLink jobId={job.ID} taskGroupId={taskGroup.ID}>
{taskGroup.Name}
</JobLink>
</td>
<td>
{task.Driver}
</td>
<td>
{task.Resources.CPU}
</td>
<td>
{task.Resources.MemoryMB}
</td>
<td>
{task.Resources.DiskMB}
</td>
</tr>
)
})
})
let taskGroupId = location.query.taskGroupId
let taskId = location.query.taskId
// Auto-select first task if only one is available.
if (!taskGroupId && !taskId && tasks.length === 1) {
job.TaskGroups.forEach(taskGroup => {
taskGroup.Tasks.forEach(task => {
taskGroupId = taskGroup.ID
taskId = task.ID
})
})
}
return (
<div className="tab-pane active">
<div className="row">
<div className="col-md-6 tab-column">
<legend>Tasks</legend>
{tasks.length > 0
? <TableHelper classes="table table-hover table-striped" headers={taskHeaders} body={tasks} />
: null}
</div>
<div className="col-md-6 tab-column">
<legend>
Task: {taskGroupId && taskId ? `${taskGroupId}/${taskId}` : null}
</legend>
{job.TaskGroups
.filter(taskGroup => taskGroup.ID === taskGroupId)
.map(taskGroup =>
taskGroup.Tasks.filter(task => task.ID === taskId).map(task => <RawJson json={task} />).pop()
)
.pop()}
</div>
</div>
</div>
)
}
function mapStateToProps({ job }) {
return { job }
}
JobTasks.propTypes = {
job: PropTypes.object.isRequired,
location: PropTypes.object.isRequired
}
export default connect(mapStateToProps)(JobTasks)
|
tinyMCE.addI18n('tw.template_dlg',{
title:"\u7BC4\u672C\u6A19\u984C",
label:"\u7BC4\u672C",
desc_label:"\u63CF\u8FF0",
desc:"\u63D2\u5165\u9810\u5B9A\u7684\u7BC4\u672C\u5167\u5BB9",
select:"\u9078\u64C7\u7BC4\u672C",
preview:"\u9810\u89BD",
warning:"\u8B66\u544A:\u66F4\u65B0\u7BC4\u672C\u6709\u53EF\u80FD\u5C0E\u81F4\u8CC7\u6599\u907A\u5931\u3002",
mdate_format:"%Y-%m-%d %H:%M:%S",
cdate_format:"%Y-%m-%d %H:%M:%S",
months_long:"\u4E00\u6708\uFF0C\u4E8C\u6708\uFF0C\u4E09\u6708\uFF0C\u56DB\u6708\uFF0C\u4E94\u6708\uFF0C\u516D\u6708\uFF0C\u4E03\u6708\uFF0C\u516B\u6708\uFF0C\u4E5D\u6708\uFF0C\u5341\u6708\uFF0C\u5341\u4E00\u6708\uFF0C\u5341\u4E8C\u6708",
months_short:"1\u6708\uFF0C2\u6708\uFF0C3\u6708\uFF0C4\u6708\uFF0C5\u6708\uFF0C6\u6708\uFF0C7\u6708\uFF0C8\u6708\uFF0C9\u6708\uFF0C10\u6708\uFF0C11\u6708\uFF0C12\u6708",
day_long:"\u661F\u671F\u65E5\uFF0C\u661F\u671F\u4E00\uFF0C\u661F\u671F\u4E8C\uFF0C\u661F\u671F\u4E09\uFF0C\u661F\u671F\u56DB\uFF0C\u661F\u671F\u4E94\uFF0C\u661F\u671F\u516D\uFF0C\u661F\u671F\u65E5",
day_short:"\u9031\u65E5\uFF0C\u9031\u4E00\uFF0C\u9031\u4E8C\uFF0C\u9031\u4E09\uFF0C\u9031\u56DB\uFF0C\u9031\u4E94\uFF0C\u9031\u516D\uFF0C\u9031\u65E5"
});
|
module.exports = function (grunt) {
// Full list of files that must be included by RequireJS
includes = [
'jquery.select2'
];
amdIncludes = [
'almond'
];
fullIncludes = [
'jquery',
'jquery.mousewheel',
'select2/compat/matcher',
'select2/compat/initSelection',
'select2/compat/inputData',
'select2/compat/query',
'select2/dropdown/attachContainer',
'select2/dropdown/stopPropagation',
'select2/selection/stopPropagation'
].concat(includes);
var i18nModules = [];
var i18nPaths = {};
var i18nFiles = grunt.file.expand({
cwd: 'src/js'
}, 'select2/i18n/*.js');
var testFiles = grunt.file.expand('tests/**/*.html');
var testUrls = testFiles.map(function (filePath) {
return 'http://localhost:9999/' + filePath;
});
var testBuildNumber = "unknown";
if (process.env.TRAVIS_JOB_ID) {
testBuildNumber = "travis-" + process.env.TRAVIS_JOB_ID;
} else {
var currentTime = new Date();
testBuildNumber = "manual-" + currentTime.getTime();
}
for (var i = 0; i < i18nFiles.length; i++) {
var file = i18nFiles[i];
var name = file.split('.')[0];
i18nModules.push({
name: name
});
i18nPaths[name] = '../../' + name;
}
grunt.initConfig({
clean: {
docs: ['docs/_site']
},
connect: {
tests: {
options: {
base: '.',
hostname: '127.0.0.1',
port: 9999
}
}
},
uglify: {
'dist': {
src: 'dist/js/select2.js',
dest: 'dist/js/select2.min.js'
},
'dist.full': {
src: 'dist/js/select2.full.js',
dest: 'dist/js/select2.full.min.js'
}
},
qunit: {
all: {
options: {
urls: testUrls
}
}
},
'saucelabs-qunit': {
all: {
options: {
build: testBuildNumber,
tags: ['tests', 'qunit'],
urls: testUrls,
testname: 'QUnit test for Select2',
browsers: [
{
browserName: 'internet explorer',
version: '9'
},
{
browserName: 'internet explorer',
version: '10'
},
{
browserName: 'firefox'
},
{
browserName: 'chrome'
},
{
browserName: 'opera',
version: '12'
},
{
browserName: 'opera'
}
]
}
}
},
'gh-pages': {
options: {
base: 'docs',
branch: 'master',
clone: 'node_modules/grunt-gh-pages/repo',
message: 'Updated docs with master',
push: true,
repo: 'git@github.com:select2/select2.github.io.git'
},
src: '**'
},
jekyll: {
options: {
src: 'docs',
dest: 'docs/_site'
},
build: {
d: null
},
serve: {
options: {
serve: true,
watch: true
}
}
},
jshint: {
options: {
jshintrc: true
},
code: {
src: ['src/js/**/*.js']
},
tests: {
src: ['tests/**/*.js']
}
},
sass: {
dist: {
options: {
outputStyle: 'compressed'
},
files: {
'dist/css/select2.min.css': [
'src/scss/core.scss',
'src/scss/theme/default/layout.css'
]
}
},
dev: {
options: {
outputStyle: 'nested'
},
files: {
'dist/css/select2.css': [
'src/scss/core.scss',
'src/scss/theme/default/layout.css'
]
}
}
},
symlink: {
docs: {
cwd: 'dist',
expand: true,
overwrite: false,
src: [
'*'
],
dest: 'docs/dist',
filter: 'isDirectory'
}
},
requirejs: {
'dist': {
options: {
baseUrl: 'src/js',
optimize: 'none',
name: 'select2/core',
out: 'dist/js/select2.js',
include: amdIncludes.concat(includes),
paths: {
almond: '../../vendor/almond-0.2.9',
jquery: 'jquery.shim'
},
wrap: grunt.file.readJSON('src/js/banner.json')
}
},
'dist.full': {
options: {
baseUrl: 'src/js',
optimize: 'none',
name: 'select2/core',
out: 'dist/js/select2.full.js',
include: amdIncludes.concat(fullIncludes),
paths: {
almond: '../../vendor/almond-0.2.9',
jquery: 'jquery.shim',
'jquery.mousewheel': '../../vendor/jquery.mousewheel'
},
wrap: grunt.file.readJSON('src/js/banner.json')
}
},
'amd': {
options: {
baseUrl: 'src/js',
optimize: 'none',
name: 'select2/core',
out: 'dist/js/select2.amd.js',
include: includes,
paths: {
jquery: 'empty:'
},
wrap: grunt.file.readJSON('src/js/banner.amd.json')
}
},
'amd.full': {
options: {
baseUrl: 'src/js',
optimize: 'none',
name: 'select2/core',
out: 'dist/js/select2.amd.full.js',
include: fullIncludes,
paths: {
jquery: 'empty:',
'jquery.mousewheel': '../../vendor/jquery.mousewheel'
},
wrap: grunt.file.readJSON('src/js/banner.amd.json')
}
},
'i18n': {
options: {
baseUrl: 'src/js/select2/i18n',
dir: 'dist/js/i18n',
paths: i18nPaths,
modules: i18nModules,
wrap: grunt.file.readJSON('src/js/banner.json')
}
}
},
watch: {
js: {
files: [
'src/js/select2/**/*.js',
'tests/**/*.js'
],
tasks: [
'compile',
'test',
'minify'
]
},
css: {
files: [
'src/scss/**/*.scss'
],
tasks: [
'compile',
'minify'
]
}
}
});
grunt.loadNpmTasks('grunt-contrib-clean');
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.loadNpmTasks('grunt-contrib-connect');
grunt.loadNpmTasks('grunt-contrib-jshint');
grunt.loadNpmTasks('grunt-contrib-qunit');
grunt.loadNpmTasks('grunt-contrib-requirejs');
grunt.loadNpmTasks('grunt-contrib-symlink');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-gh-pages');
grunt.loadNpmTasks('grunt-jekyll');
grunt.loadNpmTasks('grunt-saucelabs');
grunt.loadNpmTasks('grunt-sass');
grunt.registerTask('default', ['compile', 'test', 'minify']);
grunt.registerTask('compile', ['requirejs', 'sass:dev']);
grunt.registerTask('minify', ['uglify', 'sass:dist']);
grunt.registerTask('test', ['connect:tests', 'qunit', 'jshint']);
var ciTasks = [];
ciTasks.push('compile')
ciTasks.push('connect:tests');
// Can't run Sauce Labs tests in pull requests
if (process.env.TRAVIS_PULL_REQUEST == 'false') {
ciTasks.push('saucelabs-qunit');
}
ciTasks.push('qunit');
ciTasks.push('jshint');
grunt.registerTask('ci', ciTasks);
grunt.registerTask('docs', ['symlink:docs', 'jekyll:serve']);
grunt.registerTask('docs-release', ['default', 'clean:docs', 'gh-pages']);
};
|
this.recline = this.recline || {};
this.recline.Backend = this.recline.Backend || {};
this.recline.Backend.GDocs = this.recline.Backend.GDocs || {};
(function($, my) {
my.__type__ = 'gdocs';
// ## Google spreadsheet backend
//
// Fetch data from a Google Docs spreadsheet.
//
// Dataset must have a url attribute pointing to the Gdocs or its JSON feed e.g.
// <pre>
// var dataset = new recline.Model.Dataset({
// url: 'https://docs.google.com/spreadsheet/ccc?key=0Aon3JiuouxLUdGlQVDJnbjZRSU1tUUJWOUZXRG53VkE#gid=0'
// },
// 'gdocs'
// );
//
// var dataset = new recline.Model.Dataset({
// url: 'https://spreadsheets.google.com/feeds/list/0Aon3JiuouxLUdDQwZE1JdV94cUd6NWtuZ0IyWTBjLWc/od6/public/values?alt=json'
// },
// 'gdocs'
// );
// </pre>
//
// @return object with two attributes
//
// * fields: array of Field objects
// * records: array of objects for each row
my.fetch = function(dataset) {
var dfd = $.Deferred();
var urls = my.getGDocsAPIUrls(dataset.url);
// TODO cover it with tests
// get the spreadsheet title
(function () {
var titleDfd = $.Deferred();
$.getJSON(urls.spreadsheet, function (d) {
titleDfd.resolve({
spreadsheetTitle: d.feed.title.$t
});
});
return titleDfd.promise();
}()).then(function (response) {
// get the actual worksheet data
$.getJSON(urls.worksheet, function(d) {
var result = my.parseData(d);
var fields = _.map(result.fields, function(fieldId) {
return {id: fieldId};
});
dfd.resolve({
metadata: {
title: response.spreadsheetTitle +" :: "+ result.worksheetTitle,
spreadsheetTitle: response.spreadsheetTitle,
worksheetTitle : result.worksheetTitle
},
records : result.records,
fields : fields,
useMemoryStore: true
});
});
});
return dfd.promise();
};
// ## parseData
//
// Parse data from Google Docs API into a reasonable form
//
// :options: (optional) optional argument dictionary:
// columnsToUse: list of columns to use (specified by field names)
// colTypes: dictionary (with column names as keys) specifying types (e.g. range, percent for use in conversion).
// :return: tabular data object (hash with keys: field and data).
//
// Issues: seems google docs return columns in rows in random order and not even sure whether consistent across rows.
my.parseData = function(gdocsSpreadsheet, options) {
var options = options || {};
var colTypes = options.colTypes || {};
var results = {
fields : [],
records: []
};
var entries = gdocsSpreadsheet.feed.entry || [];
var key;
var colName;
// percentage values (e.g. 23.3%)
var rep = /^([\d\.\-]+)\%$/;
for(key in entries[0]) {
// it's barely possible it has inherited keys starting with 'gsx$'
if(/^gsx/.test(key)) {
colName = key.substr(4);
results.fields.push(colName);
}
}
// converts non numberical values that should be numerical (22.3%[string] -> 0.223[float])
results.records = _.map(entries, function(entry) {
var row = {};
_.each(results.fields, function(col) {
var _keyname = 'gsx$' + col;
var value = entry[_keyname].$t;
var num;
// TODO cover this part of code with test
// TODO use the regexp only once
// if labelled as % and value contains %, convert
if(colTypes[col] === 'percent' && rep.test(value)) {
num = rep.exec(value)[1];
value = parseFloat(num) / 100;
}
row[col] = value;
});
return row;
});
results.worksheetTitle = gdocsSpreadsheet.feed.title.$t;
return results;
};
// Convenience function to get GDocs JSON API Url from standard URL
my.getGDocsAPIUrls = function(url) {
// https://docs.google.com/spreadsheet/ccc?key=XXXX#gid=YYY
var regex = /.*spreadsheet\/ccc?.*key=([^#?&+]+).*gid=([\d]+).*/;
var matches = url.match(regex);
var key;
var worksheet;
var urls;
if(!!matches) {
key = matches[1];
// the gid in url is 0-based and feed url is 1-based
worksheet = parseInt(matches[2]) + 1;
urls = {
worksheet : 'https://spreadsheets.google.com/feeds/list/'+ key +'/'+ worksheet +'/public/values?alt=json',
spreadsheet: 'https://spreadsheets.google.com/feeds/worksheets/'+ key +'/public/basic?alt=json'
}
}
else {
// we assume that it's one of the feeds urls
key = url.split('/')[5];
// by default then, take first worksheet
worksheet = 1;
urls = {
worksheet : 'https://spreadsheets.google.com/feeds/list/'+ key +'/'+ worksheet +'/public/values?alt=json',
spreadsheet: 'https://spreadsheets.google.com/feeds/worksheets/'+ key +'/public/basic?alt=json'
}
}
return urls;
};
}(jQuery, this.recline.Backend.GDocs));
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.