Showing 228 of 9,694 total issues
File live2d.core.js
has 7593 lines of code (exceeds 250 allowed). Consider refactoring. Open
/**
* ============================================================
* Live2D Cubism SDK for WebGL Version 2.1.00_1
*
* (c) Live2D Inc.
Function loadMotion
has a Cognitive Complexity of 186 (exceeds 5 allowed). Consider refactoring. Open
ao.loadMotion = function(aT) {
if (aT instanceof ArrayBuffer) {
aT = new DataView(aT);
}
var aN = new ao();
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function loadMotion
has a Cognitive Complexity of 185 (exceeds 5 allowed). Consider refactoring. Open
Y.loadMotion = function(aR) {
var aM = new Y();
var aI = [0];
var aP = aR.length;
aM._$yT = 0;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function transformPoints_sdk2
has a Cognitive Complexity of 175 (exceeds 5 allowed). Consider refactoring. Open
E.transformPoints_sdk2 = function(a0, bc, a5, aP, aI, aR, aQ, aU) {
var aW = a5 * aI;
var aV;
var bn, bm;
var aT = 0;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File _Live2DFramework.official.js
has 914 lines of code (exceeds 250 allowed). Consider refactoring. Open
/**
*
* You can modify and use this source freely
* only for the development of application related Live2D.
*
File Live2DFramework.js
has 817 lines of code (exceeds 250 allowed). Consider refactoring. Open
/**
*
* You can modify and use this source freely
* only for the development of application related Live2D.
*
Function _$Vr
has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring. Open
aG._$Vr = function(bV, bW, a5, aI, bC, a3, bX, bH) {
var aN = bW._$Q2(bV, a5);
var bw = bV._$vs();
var a2 = bV._$Tr();
bW._$zr(bw, a2, aN);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$P7
has a Cognitive Complexity of 72 (exceeds 5 allowed). Consider refactoring. Open
aa.prototype._$P7 = function(aK, aR, aH, a0) {
var aU = -1;
var aY = 0;
var aM = this;
var aJ = 0.5;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function transformPoints_sdk2
has 238 lines of code (exceeds 25 allowed). Consider refactoring. Open
E.transformPoints_sdk2 = function(a0, bc, a5, aP, aI, aR, aQ, aU) {
var aW = a5 * aI;
var aV;
var bn, bm;
var aT = 0;
Function _$Q2
has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring. Open
g.prototype._$Q2 = function(aL, aV) {
var aX = this._$Ob.length;
var aJ = aL._$v2();
var aN = 0;
var aI;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$Nr
has a Cognitive Complexity of 55 (exceeds 5 allowed). Consider refactoring. Open
ab.prototype._$Nr = function(bf, bx) {
if (!((this == bx._$GT()))) {
console.log("### assert!! ### ");
}
var bm = bx;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$Z2
has a Cognitive Complexity of 53 (exceeds 5 allowed). Consider refactoring. Open
aG._$Z2 = function(bb, bo, bp, a2) {
var a1 = bo._$Q2(bb, bp);
var a3 = bb._$vs();
var ba = bb._$Tr();
bo._$zr(a3, ba, a1);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$br
has a Cognitive Complexity of 53 (exceeds 5 allowed). Consider refactoring. Open
aG._$br = function(ba, bo, bp, bg) {
var a1 = bo._$Q2(ba, bp);
var a2 = ba._$vs();
var a9 = ba._$Tr();
bo._$zr(a2, a9, a1);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$Nr
has 197 lines of code (exceeds 25 allowed). Consider refactoring. Open
ab.prototype._$Nr = function(bf, bx) {
if (!((this == bx._$GT()))) {
console.log("### assert!! ### ");
}
var bm = bx;
Function setupLayoutBounds
has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring. Open
W.prototype.setupLayoutBounds = function(aQ) {
var aI = aQ / W.CHANNEL_COUNT;
var aP = aQ % W.CHANNEL_COUNT;
aI = ~~aI;
aP = ~~aP;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _$Vr
has 166 lines of code (exceeds 25 allowed). Consider refactoring. Open
aG._$Vr = function(bV, bW, a5, aI, bC, a3, bX, bH) {
var aN = bW._$Q2(bV, a5);
var bw = bV._$vs();
var a2 = bV._$Tr();
bW._$zr(bw, a2, aN);
Function update
has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring. Open
y.prototype.update = function() {
if (y._$e) {
q.start("_$zL");
}
var aK = this._$_2.length;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function loadMotion
has 144 lines of code (exceeds 25 allowed). Consider refactoring. Open
ao.loadMotion = function(aT) {
if (aT instanceof ArrayBuffer) {
aT = new DataView(aT);
}
var aN = new ao();
Function loadMotion
has 140 lines of code (exceeds 25 allowed). Consider refactoring. Open
Y.loadMotion = function(aR) {
var aM = new Y();
var aI = [0];
var aP = aR.length;
aM._$yT = 0;
Function updateParamExe
has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring. Open
ao.prototype.updateParamExe = function(aJ, aN, aQ, a3) {
var aO = aN - a3._$z2;
var a0 = aO * this._$D0 / 1000;
var aK = a0 | 0;
var aR = a0 - aK;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"