From 97ef2458fd74bd66e54faf4221b47b18a1613a5f Mon Sep 17 00:00:00 2001 From: Kolyah35 Date: Wed, 18 Mar 2026 12:51:32 +0300 Subject: [PATCH] first commit --- README.md | 223 +++ RENAMING_MAP.json | 689 +++++++++ com/m3gworks/engine/GameAppMidlet.java | 40 + .../microcs/MicroCounterStrikeMidlet.java | 40 + com/m3gworks/util/EngineTestMidlet.java | 21 + p000/AiControllerBase.java | 57 + p000/AnimatedBillboardSprite.java | 162 +++ p000/AxisAlignedBoundingBox.java | 185 +++ p000/BillboardSprite.java | 67 + p000/BluetoothClientSync.java | 238 ++++ p000/BluetoothControlChannel.java | 127 ++ p000/BluetoothDiscoveryClient.java | 238 ++++ p000/BluetoothHostSync.java | 254 ++++ p000/BluetoothServerListener.java | 120 ++ p000/BotAIController.java | 83 ++ p000/BulletHoleManager.java | 134 ++ p000/CameraManager.java | 67 + p000/Combatant.java | 26 + p000/ConnectionManager.java | 108 ++ p000/CountdownTimerTask.java | 23 + p000/DefaultPlatformServices.java | 949 +++++++++++++ p000/FastAcos.java | 20 + p000/GameLoadingThread.java | 214 +++ p000/GameRenderCanvas.java | 149 ++ p000/GameSessionLoop.java | 131 ++ p000/GameplayCanvas.java | 13 + p000/GameplayKeyHandler.java | 160 +++ p000/GrenadeController.java | 129 ++ p000/HudBase.java | 51 + p000/HudRenderer.java | 544 ++++++++ p000/InGameMenuOverlay.java | 550 ++++++++ p000/InputStateBase.java | 47 + p000/KeyInputHandlerBase.java | 36 + p000/LicenseInputForm.java | 85 ++ p000/LicenseKeyUtil.java | 31 + p000/LocalPlayer.java | 242 ++++ p000/MainMenuCanvas.java | 1225 +++++++++++++++++ p000/MainUiCanvasBase.java | 118 ++ p000/MapInfo.java | 21 + p000/MapManager.java | 238 ++++ p000/MuzzleFlashManager.java | 89 ++ p000/NetworkPlayerEntity.java | 221 +++ p000/NetworkStateCache.java | 21 + p000/OverlayMenuBase.java | 64 + p000/ParticleEffectManager.java | 219 +++ p000/PlatformServices.java | 119 ++ p000/PlayerEntityBase.java | 327 +++++ p000/PlayerInputController.java | 170 +++ p000/PlayerManager.java | 85 ++ p000/PlayerModel.java | 313 +++++ p000/PlayerModelBase.java | 59 + p000/PlayerMovementEntity.java | 154 +++ p000/RandomUtil.java | 11 + p000/RemotePlayer.java | 163 +++ p000/ResourceLoader.java | 166 +++ p000/RoundBasedGameMode.java | 76 + p000/SceneRootNode.java | 17 + p000/SoundManager.java | 141 ++ p000/SphereCollider.java | 35 + p000/SplashScreen.java | 87 ++ p000/VectorMath.java | 71 + p000/WeaponInfo.java | 36 + p000/WeaponLoadout.java | 159 +++ 63 files changed, 10658 insertions(+) create mode 100644 README.md create mode 100644 RENAMING_MAP.json create mode 100644 com/m3gworks/engine/GameAppMidlet.java create mode 100644 com/m3gworks/microcs/MicroCounterStrikeMidlet.java create mode 100644 com/m3gworks/util/EngineTestMidlet.java create mode 100644 p000/AiControllerBase.java create mode 100644 p000/AnimatedBillboardSprite.java create mode 100644 p000/AxisAlignedBoundingBox.java create mode 100644 p000/BillboardSprite.java create mode 100644 p000/BluetoothClientSync.java create mode 100644 p000/BluetoothControlChannel.java create mode 100644 p000/BluetoothDiscoveryClient.java create mode 100644 p000/BluetoothHostSync.java create mode 100644 p000/BluetoothServerListener.java create mode 100644 p000/BotAIController.java create mode 100644 p000/BulletHoleManager.java create mode 100644 p000/CameraManager.java create mode 100644 p000/Combatant.java create mode 100644 p000/ConnectionManager.java create mode 100644 p000/CountdownTimerTask.java create mode 100644 p000/DefaultPlatformServices.java create mode 100644 p000/FastAcos.java create mode 100644 p000/GameLoadingThread.java create mode 100644 p000/GameRenderCanvas.java create mode 100644 p000/GameSessionLoop.java create mode 100644 p000/GameplayCanvas.java create mode 100644 p000/GameplayKeyHandler.java create mode 100644 p000/GrenadeController.java create mode 100644 p000/HudBase.java create mode 100644 p000/HudRenderer.java create mode 100644 p000/InGameMenuOverlay.java create mode 100644 p000/InputStateBase.java create mode 100644 p000/KeyInputHandlerBase.java create mode 100644 p000/LicenseInputForm.java create mode 100644 p000/LicenseKeyUtil.java create mode 100644 p000/LocalPlayer.java create mode 100644 p000/MainMenuCanvas.java create mode 100644 p000/MainUiCanvasBase.java create mode 100644 p000/MapInfo.java create mode 100644 p000/MapManager.java create mode 100644 p000/MuzzleFlashManager.java create mode 100644 p000/NetworkPlayerEntity.java create mode 100644 p000/NetworkStateCache.java create mode 100644 p000/OverlayMenuBase.java create mode 100644 p000/ParticleEffectManager.java create mode 100644 p000/PlatformServices.java create mode 100644 p000/PlayerEntityBase.java create mode 100644 p000/PlayerInputController.java create mode 100644 p000/PlayerManager.java create mode 100644 p000/PlayerModel.java create mode 100644 p000/PlayerModelBase.java create mode 100644 p000/PlayerMovementEntity.java create mode 100644 p000/RandomUtil.java create mode 100644 p000/RemotePlayer.java create mode 100644 p000/ResourceLoader.java create mode 100644 p000/RoundBasedGameMode.java create mode 100644 p000/SceneRootNode.java create mode 100644 p000/SoundManager.java create mode 100644 p000/SphereCollider.java create mode 100644 p000/SplashScreen.java create mode 100644 p000/VectorMath.java create mode 100644 p000/WeaponInfo.java create mode 100644 p000/WeaponLoadout.java diff --git a/README.md b/README.md new file mode 100644 index 0000000..6612436 --- /dev/null +++ b/README.md @@ -0,0 +1,223 @@ +# Micro Counter Strike + +> [!Warning] +> This code completely auto-generated by ChatGPT from obfuscated JADx decompilation of Micro Counter Strike. + +# Renaming Map +This folder contains a readability refactor of the decompiled sources. All obfuscated class names and all obfuscated member names matching `f###x`, `m###x`, `mo###x` were renamed. +## Class renames +| Old | New | +|---|---| +| `AbstractC0016ap` | `AiControllerBase` | +| `AbstractC0019as` | `InputStateBase` | +| `AbstractC0037f` | `MainUiCanvasBase` | +| `AbstractC0038g` | `OverlayMenuBase` | +| `AbstractC0040i` | `HudBase` | +| `AbstractC0041j` | `KeyInputHandlerBase` | +| `AbstractC0043l` | `PlatformServices` | +| `AbstractC0048q` | `PlayerModelBase` | +| `AbstractC0052u` | `PlayerEntityBase` | +| `AbstractRunnableC0014an` | `GameSessionLoop` | +| `C0000a` | `SceneRootNode` | +| `C0001aa` | `MapManager` | +| `C0002ab` | `GameRenderCanvas` | +| `C0003ac` | `CountdownTimerTask` | +| `C0004ad` | `InGameMenuOverlay` | +| `C0005ae` | `MainMenuCanvas` | +| `C0006af` | `GrenadeController` | +| `C0007ag` | `FastAcos` | +| `C0008ah` | `LocalPlayer` | +| `C0009ai` | `MapInfo` | +| `C0011ak` | `LicenseKeyUtil` | +| `C0012al` | `BluetoothHostSync` | +| `C0013am` | `BillboardSprite` | +| `C0015ao` | `LicenseInputForm` | +| `C0017aq` | `CameraManager` | +| `C0018ar` | `RoundBasedGameMode` | +| `C0020at` | `GameplayKeyHandler` | +| `C0021au` | `ResourceLoader` | +| `C0023aw` | `SphereCollider` | +| `C0024ax` | `DefaultPlatformServices` | +| `C0025ay` | `AxisAlignedBoundingBox` | +| `C0026az` | `WeaponLoadout` | +| `C0027b` | `AnimatedBillboardSprite` | +| `C0029bb` | `PlayerManager` | +| `C0031bd` | `SoundManager` | +| `C0032be` | `RemotePlayer` | +| `C0033bf` | `MuzzleFlashManager` | +| `C0034c` | `NetworkStateCache` | +| `C0035d` | `ConnectionManager` | +| `C0039h` | `PlayerInputController` | +| `C0042k` | `WeaponInfo` | +| `C0044m` | `BluetoothClientSync` | +| `C0045n` | `NetworkPlayerEntity` | +| `C0046o` | `VectorMath` | +| `C0049r` | `BotAIController` | +| `C0050s` | `RandomUtil` | +| `C0051t` | `PlayerModel` | +| `C0053v` | `ParticleEffectManager` | +| `C0054w` | `PlayerMovementEntity` | +| `C0055x` | `BulletHoleManager` | +| `C0056y` | `HudRenderer` | +| `C0057z` | `GameplayCanvas` | +| `GameMIDlet` | `GameAppMidlet` | +| `InterfaceC0030bc` | `Combatant` | +| `MicroCsMIDlet` | `MicroCounterStrikeMidlet` | +| `RunnableC0010aj` | `GameLoadingThread` | +| `RunnableC0022av` | `BluetoothControlChannel` | +| `RunnableC0028ba` | `BluetoothServerListener` | +| `RunnableC0036e` | `SplashScreen` | +| `RunnableC0047p` | `BluetoothDiscoveryClient` | +| `TestMIDlet` | `EngineTestMidlet` | + +## Identifier renames (manual highlights) +Below are the most meaningful manual renames. The full mapping is in `RENAMING_MAP.json`. + +| Old | New | +|---|---| +| `f0f` | `instance` | +| `f100b` | `cachedGameplayCanvasClass` | +| `f101c` | `cachedGameModeClass` | +| `f102d` | `cachedMainMenuCanvasClass` | +| `f103e` | `cachedHudRendererClass` | +| `f104f` | `cachedInGameMenuOverlayClass` | +| `f105g` | `cachedPlayerInputControllerClass` | +| `f106h` | `cachedBotAiControllerClass` | +| `f107i` | `cachedGameplayKeyHandlerClass` | +| `f111a` | `weaponCatalog` | +| `f112b` | `defaultPrimaryWeaponId` | +| `f113c` | `defaultPistolWeaponId` | +| `f114d` | `defaultKnifeWeaponId` | +| `f115e` | `defaultAmmoPack1WeaponId` | +| `f116f` | `defaultAmmoPack2WeaponId` | +| `f117g` | `equippedWeaponIdBySlot` | +| `f118h` | `ammoBySlot` | +| `f119i` | `activeSlot` | +| `f120j` | `grenadeCharge` | +| `f133c` | `instance` | +| `f134a` | `localPlayer` | +| `f135b` | `playersById` | +| `f165a` | `display` | +| `f166b` | `instance` | +| `f177m` | `instance` | +| `f178a` | `midlet` | +| `f179b` | `graphics` | +| `f180c` | `sessionType` | +| `f188k` | `soundEnabled` | +| `f189l` | `soundEnabledPending` | +| `f1a` | `maps` | +| `f201a` | `weaponId` | +| `f202b` | `name` | +| `f203c` | `clipSize` | +| `f204d` | `defaultAmmo` | +| `f205e` | `weightLabel` | +| `f206f` | `cost` | +| `f207g` | `weaponCode` | +| `f208h` | `recoilPattern` | +| `f209i` | `crosshairPattern` | +| `f210j` | `damage` | +| `f211c` | `instance` | +| `f212a` | `uiLayoutMode` | +| `f213b` | `implClass` | +| `f2b` | `world` | +| `f3c` | `currentMapIndex` | +| `f4d` | `worldBoundsXZ` | +| `f58d` | `teamId` | +| `f59e` | `health` | +| `f5e` | `collisionCells` | +| `f60f` | `loadout` | +| `f61r` | `grenadeController` | +| `f62s` | `money` | +| `f63t` | `painSoundCounter` | +| `f64a` | `displayName` | +| `f65b` | `resourcePath` | +| `f66c` | `hasRoundTimer` | +| `f67d` | `spawnPoints` | +| `f68e` | `collisionObjectIds` | +| `f6g` | `decorations` | +| `f77e` | `instance` | +| `f78a` | `sessionType` | +| `f79b` | `sessionState` | +| `f80c` | `countdownTask` | +| `f81d` | `roundEndTriggered` | +| `m107a` | `getInstance` | +| `m108b` | `start` | +| `m10a` | `setBackgroundCrop` | +| `m11a` | `addMap` | +| `m12e` | `getCurrentMapInfo` | +| `m132a` | `loadImage` | +| `m133a` | `loadM3G` | +| `m134b` | `safeGetImage` | +| `m135c` | `safeGetM3G` | +| `m169a` | `registerWeapon` | +| `m170a` | `resetToDefaultLoadout` | +| `m171b` | `consumeAmmo` | +| `m172a` | `selectSlot` | +| `m173c` | `getActiveAmmo` | +| `m174d` | `getActiveWeaponInfo` | +| `m175b` | `addWeaponOrAmmo` | +| `m176b` | `clearSlot` | +| `m177e` | `dispose` | +| `m178f` | `clearWeaponCatalog` | +| `m191a` | `getInstance` | +| `m192a` | `addPlayer` | +| `m193a` | `addAllToWorld` | +| `m194b` | `respawnAll` | +| `m195c` | `disposeAll` | +| `m196d` | `updateVisibility` | +| `m197a` | `getPlayerById` | +| `m1a` | `getInstance` | +| `m213a` | `getInstance` | +| `m227a` | `getInstance` | +| `m228c` | `loadMenuResources` | +| `m229d` | `unloadMenuResources` | +| `m230a` | `setSoundEnabled` | +| `m242a` | `getInstance` | +| `m2b` | `loadCurrentMap` | +| `m3a` | `applyMapLighting` | +| `m4f` | `addMoonSprite` | +| `m5g` | `createTrees` | +| `m6c` | `updateDecorations` | +| `m7h` | `addDirectionalLight` | +| `m85a` | `spendMoney` | +| `m86f` | `resetPainSoundCounter` | +| `m87g` | `tryConsumePainSoundCounter` | +| `m88b` | `applyDamage` | +| `m8i` | `buildCollisionGrid` | +| `m9d` | `unloadMap` | +| `mo109c` | `onSessionStart` | +| `mo110d` | `onRoundStart` | +| `mo111e` | `onSessionEnd` | +| `mo112f` | `cleanupNetworking` | +| `mo144e` | `getGameplayCanvasClass` | +| `mo145f` | `getGameModeClass` | +| `mo146g` | `getMainMenuCanvasClass` | +| `mo147h` | `getHudRendererClass` | +| `mo148i` | `getInGameMenuOverlayClass` | +| `mo149j` | `getPlayerInputControllerClass` | +| `mo150k` | `getBotAiControllerClass` | +| `mo151l` | `getGameplayKeyHandlerClass` | +| `mo154m` | `getPreRoundSeconds` | +| `mo155n` | `getRoundEndSeconds` | +| `mo156q` | `loadMainMenuResources` | +| `mo157r` | `loadHudResources` | +| `mo158s` | `loadInGameMenuResources` | +| `mo159t` | `unloadMainMenuResources` | +| `mo160u` | `unloadHudResources` | +| `mo161v` | `unloadInGameMenuResources` | +| `mo162w` | `registerBuiltInMaps` | +| `mo163a` | `loadWeaponDefinitions` | +| `mo164x` | `initCameras` | +| `mo214b` | `onStartApp` | +| `mo215c` | `onPauseApp` | +| `mo216d` | `onDestroyApp` | +| `mo79a` | `addToWorld` | +| `mo80a` | `removeFromWorld` | +| `mo81b` | `respawn` | +| `mo82e` | `handleAction` | +| `mo83a` | `onHit` | +| `mo84a` | `findHitTarget` | +| `mo89j` | `getHealth` | +| `mo90k` | `getLoadout` | +| `mo91l` | `getGrenadeController` | +| `mo92m` | `getTeamId` | diff --git a/RENAMING_MAP.json b/RENAMING_MAP.json new file mode 100644 index 0000000..a3a0498 --- /dev/null +++ b/RENAMING_MAP.json @@ -0,0 +1,689 @@ +{ + "classes": { + "AbstractC0016ap": "AiControllerBase", + "AbstractC0019as": "InputStateBase", + "AbstractC0037f": "MainUiCanvasBase", + "AbstractC0038g": "OverlayMenuBase", + "AbstractC0040i": "HudBase", + "AbstractC0041j": "KeyInputHandlerBase", + "AbstractC0043l": "PlatformServices", + "AbstractC0048q": "PlayerModelBase", + "AbstractC0052u": "PlayerEntityBase", + "C0000a": "SceneRootNode", + "C0001aa": "MapManager", + "C0002ab": "GameRenderCanvas", + "C0003ac": "CountdownTimerTask", + "C0004ad": "InGameMenuOverlay", + "C0005ae": "MainMenuCanvas", + "C0006af": "GrenadeController", + "C0007ag": "FastAcos", + "C0008ah": "LocalPlayer", + "C0009ai": "MapInfo", + "C0011ak": "LicenseKeyUtil", + "C0012al": "BluetoothHostSync", + "C0013am": "BillboardSprite", + "C0017aq": "CameraManager", + "C0018ar": "RoundBasedGameMode", + "C0020at": "GameplayKeyHandler", + "C0021au": "ResourceLoader", + "C0023aw": "SphereCollider", + "C0024ax": "DefaultPlatformServices", + "C0025ay": "AxisAlignedBoundingBox", + "C0026az": "WeaponLoadout", + "C0027b": "AnimatedBillboardSprite", + "C0029bb": "PlayerManager", + "C0031bd": "SoundManager", + "C0032be": "RemotePlayer", + "C0033bf": "MuzzleFlashManager", + "C0034c": "NetworkStateCache", + "C0035d": "ConnectionManager", + "C0039h": "PlayerInputController", + "C0042k": "WeaponInfo", + "C0044m": "BluetoothClientSync", + "C0045n": "NetworkPlayerEntity", + "C0046o": "VectorMath", + "C0049r": "BotAIController", + "C0050s": "RandomUtil", + "C0051t": "PlayerModel", + "C0053v": "ParticleEffectManager", + "C0054w": "PlayerMovementEntity", + "C0055x": "BulletHoleManager", + "C0056y": "HudRenderer", + "C0057z": "GameplayCanvas", + "InterfaceC0030bc": "Combatant", + "RunnableC0010aj": "GameLoadingThread", + "RunnableC0022av": "BluetoothControlChannel", + "RunnableC0028ba": "BluetoothServerListener", + "RunnableC0036e": "SplashScreen", + "RunnableC0047p": "BluetoothDiscoveryClient", + "GameMIDlet": "GameAppMidlet", + "MicroCsMIDlet": "MicroCounterStrikeMidlet", + "TestMIDlet": "EngineTestMidlet", + "AbstractRunnableC0014an": "GameSessionLoop", + "C0015ao": "LicenseInputForm" + }, + "identifiers": { + "f224c": "bluetoothDiscoveryClient224", + "f225d": "discoveryAgent225", + "f226e": "uUIDArr226", + "f227f": "CONST_UUID227", + "f228g": "value228", + "f229h": "list229", + "f230a": "list230", + "f231i": "value231", + "f232j": "value232", + "f233b": "bluetoothControlChannel233", + "f181d": "value181", + "f182e": "value182", + "f183f": "value183", + "f184g": "value184", + "f185h": "value185", + "f186i": "value186", + "f187j": "value187", + "f154e": "muzzleFlashManager154", + "f155a": "texture155", + "f156b": "image156", + "f157c": "texture157", + "f158d": "image158", + "f159f": "list159", + "f92a": "inputStateBase92", + "f93c": "flag93", + "f90e": "value90", + "f91f": "value91", + "f234a": "node234", + "f235b": "node235", + "f236c": "playerEntityBase236", + "f73a": "bluetoothHostSync73", + "f74b": "networkStateCache74", + "f69c": "gameLoadingThread69", + "f70d": "flag70", + "f71a": "value71", + "f72b": "value72", + "f11a": "value11", + "f86a": "aiControllerBase86", + "f13d": "value13", + "f14e": "value14", + "f18i": "value18", + "f24o": "flag24", + "f25p": "value25", + "f12c": "CONST_TEXT12", + "f15f": "image15", + "f16g": "image16", + "f17h": "image17", + "f19j": "CONST_VALUE19", + "f20k": "CONST_TEXT20", + "f21l": "CONST_TEXT21", + "f22m": "CONST_TEXT22", + "f23n": "CONST_TEXT23", + "f136a": "soundManager136", + "f137b": "playerArr137", + "f138c": "playerArr138", + "f139d": "playerArr139", + "f140e": "playerArr140", + "f141f": "playerArr141", + "f142g": "value142", + "f143h": "value143", + "f144i": "value144", + "f145j": "value145", + "f146k": "value146", + "f287a": "value287", + "f288b": "value288", + "f290d": "text290", + "f291e": "value291", + "f292f": "value292", + "f289c": "text289", + "f293g": "image293", + "f294h": "image294", + "f295i": "image295", + "f296j": "image296", + "f297k": "image297", + "f298l": "image298", + "f299m": "image299", + "f300n": "image300", + "f301o": "CONST_VALUE301", + "f302p": "CONST_VALUE302", + "f303q": "CONST_VALUE303", + "f304r": "CONST_VALUE304", + "f305s": "CONST_VALUE305", + "f306t": "CONST_VALUE306", + "f307u": "CONST_VALUE307", + "f308v": "CONST_VALUE308", + "f309w": "CONST_VALUE309", + "f310x": "CONST_VALUE310", + "f311y": "CONST_VALUE311", + "f312z": "CONST_VALUE312", + "f160a": "value160", + "f161b": "value161", + "f162c": "value162", + "f163d": "value163", + "f164e": "value164", + "f280a": "bulletHoleManager280", + "f281b": "mesh281", + "f284e": "texture284", + "f286g": "list286", + "f282c": "value282", + "f283d": "value283", + "f285f": "value285", + "f238d": "group238", + "f239e": "group239", + "f240f": "group240", + "f241g": "group241", + "f242r": "group242", + "f243s": "group243", + "f244h": "node244", + "f245i": "node245", + "f246j": "node246", + "f247k": "node247", + "f248l": "value248", + "f249m": "value249", + "f250t": "playerModelBase250", + "f251n": "CONST_VALUE251", + "f252o": "value252", + "f253p": "value253", + "f254q": "value254", + "f190c": "overlayMenuBase190", + "f191a": "value191", + "f192b": "flag192", + "f28m": "image28", + "f39n": "image39", + "f40o": "image40", + "f41p": "image41", + "f26q": "image26", + "f27r": "image27", + "f32v": "CONST_TEXT32", + "f33w": "CONST_TEXT33", + "f34x": "CONST_TEXT34", + "f35y": "CONST_TEXT35", + "f36z": "CONST_TEXT36", + "f29s": "value29", + "f30t": "flag30", + "f31u": "value31", + "f98a": "value98", + "f99b": "value99", + "f75a": "mesh75", + "f76b": "camera76", + "f167d": "connectionManager167", + "f168e": "connection168", + "f169a": "input169", + "f170b": "output170", + "f171c": "flag171", + "f147r": "value147", + "f148s": "value148", + "f149t": "weaponLoadout149", + "f150u": "grenadeController150", + "f151x": "animatedBillboardSprite151", + "f152v": "flag152", + "f153w": "flag153", + "f7b": "gameRenderCanvas7", + "f8c": "graphics3D8", + "f9d": "graphics9", + "f10a": "flag10", + "f199a": "hudBase199", + "f216a": "value216", + "f217r": "transform217", + "f218b": "transform218", + "f219c": "transform219", + "f220s": "value220", + "f221d": "value221", + "f222e": "value222", + "f223f": "value223", + "f276a": "transform276", + "f277b": "transform277", + "f278c": "transform278", + "f279d": "value279", + "f237a": "random237", + "f193d": "flag193", + "f194e": "value194", + "f195a": "value195", + "f196f": "value196", + "f197b": "value197", + "f198g": "value198", + "f87b": "cameraManager87", + "f88c": "map88", + "f89a": "camera89", + "f267a": "particleEffectManager267", + "f268b": "texture268", + "f269c": "texture269", + "f270d": "texture270", + "f271e": "texture271", + "f272f": "list272", + "f273g": "list273", + "f274h": "list274", + "f275i": "list275", + "f173b": "value173", + "f176e": "value176", + "f172a": "image172", + "f174c": "value174", + "f175d": "value175", + "f129a": "bluetoothServerListener129", + "f130b": "streamConnectionNotifier130", + "f131c": "CONST_UUID131", + "f132d": "flag132", + "f94c": "connection94", + "f95a": "input95", + "f96b": "output96", + "f97d": "flag97", + "f108a": "mesh108", + "f109b": "value109", + "f110c": "value110", + "f214a": "bluetoothClientSync214", + "f215b": "networkStateCache215", + "f49a": "playerEntityBase49", + "f50c": "texture50", + "f51d": "value51", + "f52e": "billboardSprite52", + "f53f": "value53", + "f54g": "value54", + "f55h": "value55", + "f56i": "flag56", + "f57b": "value57", + "f200a": "keyInputHandlerBase200", + "f255g": "value255", + "f256h": "text256", + "f257i": "value257", + "f258j": "value258", + "f259k": "value259", + "f261m": "playerModelBase261", + "f260l": "value260", + "f262n": "sphereCollider262", + "f263a": "sphereCollider263", + "f264o": "value264", + "f265p": "value265", + "f266q": "flag266", + "f121a": "mesh121", + "f122d": "appearance122", + "f123b": "texture123", + "f124e": "value124", + "f125f": "value125", + "f126c": "flag126", + "f127g": "camera127", + "f128h": "value128", + "f82a": "textField82", + "f83b": "textField83", + "f84c": "command84", + "f85d": "command85", + "m266a": "getInstance", + "m267b": "execute267", + "m268c": "execute268", + "m269a": "execute269", + "m270d": "execute270", + "m207a": "getInstance", + "m208b": "execute208", + "m209a": "getAnimatedBillboardSprite209", + "m210c": "execute210", + "m211d": "execute211", + "m212e": "execute212", + "m124b": "getInstance", + "mo126a": "execute126", + "m123a": "execute123", + "mo271a": "execute271", + "m272a": "execute272", + "m273a": "execute273", + "mo127a": "execute127", + "mo128b": "execute128", + "m102a": "getInstance", + "m103b": "sendPacket103", + "m93a": "getInstance", + "m94b": "execute94", + "m95c": "showScreen95", + "m96f": "execute96", + "m97g": "execute97", + "m98d": "execute98", + "m99e": "execute99", + "m113a": "getInstance", + "m114b": "execute114", + "m116b": "execute116", + "m22a": "loadImages22", + "mo23a": "execute23", + "m24a": "execute24", + "m25b": "execute25", + "m26c": "execute26", + "m27d": "execute27", + "m28e": "execute28", + "mo29a": "execute29", + "m30b": "execute30", + "m31c": "execute31", + "m32f": "execute32", + "m33d": "execute33", + "mo34d": "execute34", + "mo35e": "execute35", + "m36b": "execute36", + "m198a": "getInstance", + "m199a": "execute199", + "m200a": "execute200", + "m201c": "execute201", + "m202b": "execute202", + "mo236a": "execute236", + "m308a": "execute308", + "m309b": "execute309", + "mo237a": "execute237", + "m310e": "execute310", + "m311f": "execute311", + "mo238b": "execute238", + "m312c": "loadImages312", + "m313d": "execute313", + "mo0a": "loadM3G0", + "m302a": "getInstance", + "m303a": "execute303", + "m304a": "compute304", + "m305b": "execute305", + "m306b": "execute306", + "m307c": "execute307", + "m278b": "execute278", + "m279b": "execute279", + "m280c": "execute280", + "m231a": "execute231", + "m232b": "execute232", + "m233c": "getInstance", + "m100a": "getString100", + "m101a": "getLong101", + "mo37b": "execute37", + "m38b": "execute38", + "m39a": "execute39", + "m40e": "execute40", + "m41a": "execute41", + "m42f": "execute42", + "m43b": "execute43", + "m44g": "execute44", + "m45c": "execute45", + "m46h": "execute46", + "m47d": "execute47", + "m48i": "execute48", + "m49e": "execute49", + "m50j": "execute50", + "m51f": "execute51", + "m52k": "execute52", + "mo53a": "showScreen53", + "m54l": "execute54", + "m55g": "execute55", + "m56m": "execute56", + "m57h": "execute57", + "m58n": "execute58", + "m59o": "execute59", + "m60p": "execute60", + "m61q": "execute61", + "m62r": "execute62", + "m63i": "execute63", + "m64s": "execute64", + "m65t": "execute65", + "m66u": "execute66", + "m67v": "execute67", + "m68a": "execute68", + "m69b": "execute69", + "m70c": "loadImages70", + "m71d": "execute71", + "m139a": "getBoolean139", + "m140a": "execute140", + "m104b": "getVertexBuffer104", + "m105a": "getAppearance105", + "m106a": "execute106", + "m215a": "getInstance", + "m216a": "getInstance_2", + "m217b": "execute217", + "m218g": "execute218", + "m219h": "execute219", + "m220c": "sendPacket220", + "m221d": "sendPacket221", + "m222e": "execute222", + "m223f": "sendPacket223", + "m203b": "execute203", + "m204a": "execute204", + "m205a": "getInt205", + "m206a": "execute206", + "m13b": "initCanvas13", + "m14c": "getInstance", + "m15d": "getInstance_2", + "m16e": "execute16", + "m17h": "execute17", + "m18f": "execute18", + "mo19a": "execute19", + "m20a": "execute20", + "m21g": "execute21", + "m235a": "getInstance", + "m239c": "execute239", + "m240d": "execute240", + "mo245c": "execute245", + "mo246d": "getFloat246", + "m247a": "getFloatArray247", + "mo248a": "getFloat248", + "mo249b": "getFloat249", + "mo250c": "getFloat250", + "mo251d": "getFloat251", + "m252a": "execute252", + "m254j": "execute254", + "m255k": "execute255", + "m256a": "execute256", + "m257f": "execute257", + "m258g": "getBoolean258", + "m299a": "getFloatArray299", + "m300e": "execute300", + "m301e": "execute301", + "mo125a": "execute125", + "m234a": "execute234", + "m117a": "getInstance", + "m118b": "execute118", + "m119c": "execute119", + "m120a": "execute120", + "m121a": "getCamera121", + "m122a": "execute122", + "m129a": "loadM3G129", + "m130a": "loadImages130", + "m131a": "loadImages131", + "m132b": "loadImages132", + "m134a": "getFloatArray134", + "m290a": "getInstance", + "m291b": "execute291", + "m292a": "execute292", + "m293a": "execute293", + "m294a": "execute294", + "m295c": "execute295", + "m296a": "execute296", + "m297d": "execute297", + "m298e": "execute298", + "m224c": "execute224", + "m225a": "execute225", + "m226b": "execute226", + "m186a": "getInstance", + "m187b": "getInstance_2", + "m188e": "execute188", + "m189c": "execute189", + "m190d": "execute190", + "m135a": "sendPacket135", + "m136b": "readPacket136", + "m137c": "execute137", + "m138d": "execute138", + "m165b": "getFloatArray165", + "m166a": "getBoolean166", + "m167a": "getFloatArray167", + "m168a": "getBoolean168", + "m243a": "getInstance", + "m244b": "sendPacket244", + "m72a": "execute72", + "m73a": "execute73", + "m74a": "execute74", + "m75a": "execute75", + "m76b": "execute76", + "m77c": "execute77", + "m259a": "getFloat259", + "m260b": "getFloatArray260", + "m261a": "getFloat261", + "m262c": "getFloatArray262", + "m263b": "getFloatArray263", + "m264e": "getFloatArray264", + "m265d": "getFloatArray265", + "m241a": "getInstance", + "m281h": "execute281", + "m282b": "execute282", + "m283c": "getSphereCollider283", + "m284a": "getBoolean284", + "m285b": "getBoolean285", + "m286a": "compute286", + "m287a": "compute287", + "m288d": "getAxisAlignedBoundingBox288", + "m289i": "getFloatArray289", + "mo141b": "getBoolean141", + "mo142c": "getBoolean142", + "mo143d": "getBoolean143", + "mo152o": "getBoolean152", + "mo153p": "getBoolean153", + "m179b": "getVertexBuffer179", + "m180a": "getTexture2DArray180", + "m181a": "getAppearance181", + "m182a": "execute182", + "m183a": "execute183", + "m184a": "execute184", + "m185a": "execute185", + "m78a": "getDouble78", + "mo115a": "execute115", + "m274a": "getBoolean274", + "m275c": "execute275", + "m276a": "execute276", + "m277b": "execute277", + "f165a": "display", + "f166b": "instance", + "m213a": "getInstance", + "mo214b": "onStartApp", + "mo215c": "onPauseApp", + "mo216d": "onDestroyApp", + "f211c": "instance", + "f212a": "uiLayoutMode", + "f213b": "implClass", + "m242a": "getInstance", + "mo144e": "getGameplayCanvasClass", + "mo145f": "getGameModeClass", + "mo146g": "getMainMenuCanvasClass", + "mo147h": "getHudRendererClass", + "mo148i": "getInGameMenuOverlayClass", + "mo149j": "getPlayerInputControllerClass", + "mo150k": "getBotAiControllerClass", + "mo151l": "getGameplayKeyHandlerClass", + "mo154m": "getPreRoundSeconds", + "mo155n": "getRoundEndSeconds", + "mo156q": "loadMainMenuResources", + "mo159t": "unloadMainMenuResources", + "mo157r": "loadHudResources", + "mo160u": "unloadHudResources", + "mo158s": "loadInGameMenuResources", + "mo161v": "unloadInGameMenuResources", + "mo162w": "registerBuiltInMaps", + "mo163a": "loadWeaponDefinitions", + "mo164x": "initCameras", + "f100b": "cachedGameplayCanvasClass", + "f101c": "cachedGameModeClass", + "f102d": "cachedMainMenuCanvasClass", + "f103e": "cachedHudRendererClass", + "f104f": "cachedInGameMenuOverlayClass", + "f105g": "cachedPlayerInputControllerClass", + "f106h": "cachedBotAiControllerClass", + "f107i": "cachedGameplayKeyHandlerClass", + "f177m": "instance", + "f178a": "midlet", + "f179b": "graphics", + "f180c": "sessionType", + "f188k": "soundEnabled", + "f189l": "soundEnabledPending", + "m227a": "getInstance", + "m228c": "loadMenuResources", + "m229d": "unloadMenuResources", + "m230a": "setSoundEnabled", + "f77e": "instance", + "f78a": "sessionType", + "f79b": "sessionState", + "f80c": "countdownTask", + "f81d": "roundEndTriggered", + "m107a": "getInstance", + "m108b": "start", + "mo109c": "onSessionStart", + "mo110d": "onRoundStart", + "mo111e": "onSessionEnd", + "mo112f": "cleanupNetworking", + "f133c": "instance", + "f134a": "localPlayer", + "f135b": "playersById", + "m191a": "getInstance", + "m192a": "addPlayer", + "m193a": "addAllToWorld", + "m194b": "respawnAll", + "m195c": "disposeAll", + "m196d": "updateVisibility", + "m197a": "getPlayerById", + "f58d": "teamId", + "f59e": "health", + "f60f": "loadout", + "f61r": "grenadeController", + "f62s": "money", + "f63t": "painSoundCounter", + "m85a": "spendMoney", + "m86f": "resetPainSoundCounter", + "m87g": "tryConsumePainSoundCounter", + "m88b": "applyDamage", + "mo79a": "addToWorld", + "mo80a": "removeFromWorld", + "mo81b": "respawn", + "mo82e": "handleAction", + "mo83a": "onHit", + "mo84a": "findHitTarget", + "mo89j": "getHealth", + "mo90k": "getLoadout", + "mo91l": "getGrenadeController", + "mo92m": "getTeamId", + "f64a": "displayName", + "f65b": "resourcePath", + "f66c": "hasRoundTimer", + "f67d": "spawnPoints", + "f68e": "collisionObjectIds", + "f0f": "instance", + "f1a": "maps", + "f2b": "world", + "f3c": "currentMapIndex", + "f4d": "worldBoundsXZ", + "f5e": "collisionCells", + "f6g": "decorations", + "m1a": "getInstance", + "m2b": "loadCurrentMap", + "m3a": "applyMapLighting", + "m4f": "addMoonSprite", + "m5g": "createTrees", + "m6c": "updateDecorations", + "m7h": "addDirectionalLight", + "m8i": "buildCollisionGrid", + "m9d": "unloadMap", + "m10a": "setBackgroundCrop", + "m11a": "addMap", + "m12e": "getCurrentMapInfo", + "f201a": "weaponId", + "f202b": "name", + "f203c": "clipSize", + "f204d": "defaultAmmo", + "f205e": "weightLabel", + "f206f": "cost", + "f207g": "weaponCode", + "f208h": "recoilPattern", + "f209i": "crosshairPattern", + "f210j": "damage", + "f111a": "weaponCatalog", + "f112b": "defaultPrimaryWeaponId", + "f113c": "defaultPistolWeaponId", + "f114d": "defaultKnifeWeaponId", + "f115e": "defaultAmmoPack1WeaponId", + "f116f": "defaultAmmoPack2WeaponId", + "f117g": "equippedWeaponIdBySlot", + "f118h": "ammoBySlot", + "f119i": "activeSlot", + "f120j": "grenadeCharge", + "m169a": "registerWeapon", + "m170a": "resetToDefaultLoadout", + "m171b": "consumeAmmo", + "m172a": "selectSlot", + "m173c": "getActiveAmmo", + "m174d": "getActiveWeaponInfo", + "m175b": "addWeaponOrAmmo", + "m176b": "clearSlot", + "m177e": "dispose", + "m178f": "clearWeaponCatalog", + "m132a": "loadImage", + "m133a": "loadM3G", + "m134b": "safeGetImage", + "m135c": "safeGetM3G" + } +} \ No newline at end of file diff --git a/com/m3gworks/engine/GameAppMidlet.java b/com/m3gworks/engine/GameAppMidlet.java new file mode 100644 index 0000000..b4dca88 --- /dev/null +++ b/com/m3gworks/engine/GameAppMidlet.java @@ -0,0 +1,40 @@ +package com.m3gworks.engine; + +import javax.microedition.lcdui.Display; +import javax.microedition.midlet.MIDlet; +import javax.microedition.midlet.MIDletStateChangeException; + +/* loaded from: microcounterstrike.jar:com/m3gworks/engine/GameAppMidlet.class */ +public class GameAppMidlet extends MIDlet { + + /* renamed from: a */ + public Display display; + + /* renamed from: b */ + private static GameAppMidlet instance; + + /* renamed from: a */ + public static GameAppMidlet getInstance() { + return instance; + } + + public GameAppMidlet() { + this.display = null; + instance = this; + this.display = Display.getDisplay(this); + } + + /* renamed from: b */ + public void onStartApp() { + } + + public void startApp() throws MIDletStateChangeException { + onStartApp(); + } + + public void pauseApp() { + } + + public void destroyApp(boolean z) throws MIDletStateChangeException { + } +} diff --git a/com/m3gworks/microcs/MicroCounterStrikeMidlet.java b/com/m3gworks/microcs/MicroCounterStrikeMidlet.java new file mode 100644 index 0000000..5efc88c --- /dev/null +++ b/com/m3gworks/microcs/MicroCounterStrikeMidlet.java @@ -0,0 +1,40 @@ +package com.m3gworks.microcs; + +import com.m3gworks.engine.GameAppMidlet; +import javax.microedition.rms.RecordStore; +import javax.microedition.rms.RecordStoreException; +import javax.microedition.rms.RecordStoreFullException; +import javax.microedition.rms.RecordStoreNotFoundException; +import p000.MainUiCanvasBase; +import p000.LicenseInputForm; +import p000.SplashScreen; + +/* loaded from: microcounterstrike.jar:com/m3gworks/microcs/MicroCounterStrikeMidlet.class */ +public class MicroCounterStrikeMidlet extends GameAppMidlet { + @Override // com.m3gworks.engine.GameAppMidlet + /* renamed from: b */ + public final void onStartApp() { + byte[] record; + SplashScreen.execute225(); + boolean z = false; + RecordStore recordStore = null; + try { + RecordStore recordStoreOpenRecordStore = RecordStore.openRecordStore("m3gworksMCS", true); + z = (recordStoreOpenRecordStore.getNumRecords() == 0 || (record = recordStoreOpenRecordStore.getRecord(recordStoreOpenRecordStore.getNextRecordID() - 1)) == null || !new String(record).equals("ZHANGYUNZHI")) ? false : true; + recordStore = recordStoreOpenRecordStore; + recordStore.closeRecordStore(); + } catch (RecordStoreException e) { + recordStore.printStackTrace(); + } catch (RecordStoreNotFoundException e2) { + recordStore.printStackTrace(); + } catch (RecordStoreFullException e3) { + recordStore.printStackTrace(); + } + if (!z) { + GameAppMidlet.getInstance().display.setCurrent(new LicenseInputForm()); + } else { + GameAppMidlet.getInstance().display.setCurrent(MainUiCanvasBase.getInstance()); + MainUiCanvasBase.getInstance().execute37(); + } + } +} diff --git a/com/m3gworks/util/EngineTestMidlet.java b/com/m3gworks/util/EngineTestMidlet.java new file mode 100644 index 0000000..7876827 --- /dev/null +++ b/com/m3gworks/util/EngineTestMidlet.java @@ -0,0 +1,21 @@ +package com.m3gworks.util; + +import javax.microedition.midlet.MIDlet; +import javax.microedition.midlet.MIDletStateChangeException; +import p000.FastAcos; + +/* loaded from: microcounterstrike.jar:com/m3gworks/util/EngineTestMidlet.class */ +public class EngineTestMidlet extends MIDlet { + public EngineTestMidlet() { + System.out.println(new StringBuffer("arccos(0.5)=").append(FastAcos.getDouble78(0.5d)).toString()); + } + + public void startApp() throws MIDletStateChangeException { + } + + public void pauseApp() { + } + + public void destroyApp(boolean z) throws MIDletStateChangeException { + } +} diff --git a/p000/AiControllerBase.java b/p000/AiControllerBase.java new file mode 100644 index 0000000..71dc534 --- /dev/null +++ b/p000/AiControllerBase.java @@ -0,0 +1,57 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; + +/* renamed from: ap */ +/* loaded from: microcounterstrike.jar:ap.class */ +public abstract class AiControllerBase { + + /* renamed from: a */ + private static AiControllerBase aiControllerBase86; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [ap] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [ap] */ + /* renamed from: a */ + public static AiControllerBase getInstance() { + ?? r0 = aiControllerBase86; + if (r0 == 0) { + try { + r0 = (AiControllerBase) PlatformServices.getInstance().getBotAiControllerClass().newInstance(); + aiControllerBase86 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return aiControllerBase86; + } + + /* renamed from: b */ + public final void execute114() { + if (GameSessionLoop.getInstance().sessionState == 1) { + return; + } + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + while (enumerationKeys.hasMoreElements()) { + PlayerEntityBase abstractC0052u = (PlayerEntityBase) hashtable.get((Integer) enumerationKeys.nextElement()); + if (abstractC0052u.value257 == 2) { + execute115(abstractC0052u); + execute116(abstractC0052u); + } + } + } + + /* renamed from: a */ + public abstract void execute115(PlayerEntityBase abstractC0052u); + + /* renamed from: b */ + public static void execute116(PlayerEntityBase abstractC0052u) { + abstractC0052u.flag266 = PlayerManager.getInstance().localPlayer.getBoolean285(abstractC0052u); + } +} diff --git a/p000/AnimatedBillboardSprite.java b/p000/AnimatedBillboardSprite.java new file mode 100644 index 0000000..df76ac9 --- /dev/null +++ b/p000/AnimatedBillboardSprite.java @@ -0,0 +1,162 @@ +package p000; + +import javax.microedition.m3g.Appearance; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.CompositingMode; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.Texture2D; +import javax.microedition.m3g.TriangleStripArray; +import javax.microedition.m3g.VertexArray; +import javax.microedition.m3g.VertexBuffer; + +/* renamed from: b */ +/* loaded from: microcounterstrike.jar:b.class */ +public final class AnimatedBillboardSprite { + + /* renamed from: a */ + public Mesh mesh121; + + /* renamed from: d */ + private Appearance appearance122; + + /* renamed from: b */ + public Texture2D[] texture123; + + /* renamed from: e */ + private int value124; + + /* renamed from: f */ + private int value125; + + /* renamed from: c */ + public boolean flag126; + + /* renamed from: g */ + private Camera camera127; + + /* renamed from: h */ + private float[] value128; + + public AnimatedBillboardSprite(Image2D[] image2DArr, Camera camera, float f) { + this.value128 = new float[3]; + this.camera127 = camera; + VertexBuffer vertexBufferM179b = getVertexBuffer179(); + TriangleStripArray triangleStripArray = new TriangleStripArray(new int[]{1, 2, 0, 3}, new int[]{4}); + this.value124 = image2DArr.length; + this.value125 = 0; + this.texture123 = getTexture2DArray180(image2DArr, this.value124); + this.appearance122 = getAppearance181(this.texture123[this.value125]); + this.mesh121 = new Mesh(vertexBufferM179b, triangleStripArray, this.appearance122); + float f2 = f * 0.5f; + this.mesh121.scale(f2, f2, f2); + if (this.camera127 != null) { + this.mesh121.setAlignment(this.camera127, 148, (Node) null, 144); + } + this.mesh121.setPickingEnable(false); + execute183(false); + } + + public AnimatedBillboardSprite(Mesh mesh, Texture2D[] texture2DArr, Camera camera) { + this.value128 = new float[3]; + this.value125 = 0; + this.texture123 = texture2DArr; + this.value124 = texture2DArr.length; + this.mesh121 = mesh.duplicate(); + this.appearance122 = this.mesh121.getAppearance(0); + this.appearance122.setTexture(0, texture2DArr[this.value125]); + this.camera127 = camera; + if (this.camera127 != null) { + this.mesh121.setAlignment(this.camera127, 148, (Node) null, 144); + } + this.mesh121.setPickingEnable(false); + execute183(false); + } + + /* renamed from: b */ + private static VertexBuffer getVertexBuffer179() { + short[] sArr = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0}; + VertexArray vertexArray = new VertexArray(sArr.length / 3, 3, 2); + vertexArray.set(0, sArr.length / 3, sArr); + short[] sArr2 = {0, 1, 1, 1, 1, 0, 0, 0}; + VertexArray vertexArray2 = new VertexArray(sArr2.length / 2, 2, 2); + vertexArray2.set(0, sArr2.length / 2, sArr2); + VertexBuffer vertexBuffer = new VertexBuffer(); + vertexBuffer.setPositions(vertexArray, 0.25f, (float[]) null); + vertexBuffer.setTexCoords(0, vertexArray2, 1.0f, (float[]) null); + return vertexBuffer; + } + + /* renamed from: a */ + private static Texture2D[] getTexture2DArray180(Image2D[] image2DArr, int i) { + Texture2D[] texture2DArr = new Texture2D[i]; + for (int i2 = 0; i2 < i; i2++) { + if (image2DArr[i2] != null) { + texture2DArr[i2] = new Texture2D(image2DArr[i2]); + texture2DArr[i2].setFiltering(210, 210); + texture2DArr[i2].setWrapping(240, 240); + texture2DArr[i2].setBlending(228); + } else { + System.out.println(new StringBuffer("Image ").append(i2).append(" is null").toString()); + } + } + return texture2DArr; + } + + /* renamed from: a */ + private Appearance getAppearance181(Texture2D texture2D) { + this.appearance122 = new Appearance(); + CompositingMode compositingMode = new CompositingMode(); + compositingMode.setBlending(64); + this.appearance122.setCompositingMode(compositingMode); + this.appearance122.setTexture(0, texture2D); + return this.appearance122; + } + + /* renamed from: a */ + public final void execute182(float f, float f2, float f3) { + this.mesh121.setTranslation(f, f2, f3); + } + + /* renamed from: a */ + public final void execute183(boolean z) { + this.flag126 = z; + if (!this.flag126) { + this.mesh121.setRenderingEnable(false); + return; + } + this.mesh121.setRenderingEnable(true); + this.value125 = 0; + this.value128[0] = 0.0f; + this.value128[0] = 0.0f; + this.value128[0] = 0.0f; + } + + /* renamed from: a */ + public final void execute184() { + if (this.flag126) { + if (this.camera127 != null) { + this.mesh121.align(this.camera127); + } + if (this.value125 == this.value124) { + execute183(false); + return; + } + this.appearance122.setTexture(0, this.texture123[this.value125]); + this.value125++; + if (this.value128[0] == 0.0f && this.value128[1] == 0.0f && this.value128[2] == 0.0f) { + return; + } + float[] fArr = new float[3]; + this.mesh121.getTranslation(fArr); + float[] fArrM262c = VectorMath.getFloatArray262(fArr, this.value128); + execute182(fArrM262c[0], fArrM262c[1], fArrM262c[2]); + } + } + + /* renamed from: a */ + public final void execute185(float[] fArr) { + System.arraycopy(fArr, 0, this.value128, 0, this.value128.length); + } +} diff --git a/p000/AxisAlignedBoundingBox.java b/p000/AxisAlignedBoundingBox.java new file mode 100644 index 0000000..fdd5fe2 --- /dev/null +++ b/p000/AxisAlignedBoundingBox.java @@ -0,0 +1,185 @@ +package p000; + +import javax.microedition.m3g.Mesh; + +/* renamed from: ay */ +/* loaded from: microcounterstrike.jar:ay.class */ +public final class AxisAlignedBoundingBox { + + /* renamed from: a */ + public Mesh mesh108; + + /* renamed from: b */ + public float[] value109 = new float[3]; + + /* renamed from: c */ + public float[] value110 = new float[3]; + + public AxisAlignedBoundingBox(float[] fArr, Mesh mesh) { + this.mesh108 = mesh; + float[] fArrM165b = getFloatArray165(fArr); + this.value109[0] = fArrM165b[0]; + this.value109[1] = fArrM165b[1]; + this.value109[2] = fArrM165b[2]; + this.value110[0] = fArrM165b[3]; + this.value110[1] = fArrM165b[4]; + this.value110[2] = fArrM165b[5]; + } + + /* renamed from: b */ + private static float[] getFloatArray165(float[] fArr) { + float[] fArr2 = {Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE, -3.4028235E38f, -3.4028235E38f, -3.4028235E38f}; + for (int i = 0; i < fArr.length; i++) { + if (i % 4 == 0) { + float f = fArr[i]; + if (f < fArr2[0]) { + fArr2[0] = f; + } + if (f > fArr2[3]) { + fArr2[3] = f; + } + } else if (i % 4 == 1) { + float f2 = fArr[i]; + if (f2 < fArr2[1]) { + fArr2[1] = f2; + } + if (f2 > fArr2[4]) { + fArr2[4] = f2; + } + } else if (i % 4 == 2) { + float f3 = fArr[i]; + if (f3 < fArr2[2]) { + fArr2[2] = f3; + } + if (f3 > fArr2[5]) { + fArr2[5] = f3; + } + } + } + return fArr2; + } + + /* renamed from: a */ + public final boolean getBoolean166(SphereCollider c0023aw) { + float[] fArr = c0023aw.value98; + float f = c0023aw.value99; + float[] fArrM167a = getFloatArray167(fArr); + return (((fArrM167a[0] - fArr[0]) * (fArrM167a[0] - fArr[0])) + ((fArrM167a[1] - fArr[1]) * (fArrM167a[1] - fArr[1]))) + ((fArrM167a[2] - fArr[2]) * (fArrM167a[2] - fArr[2])) < f * f; + } + + /* renamed from: a */ + public final float[] getFloatArray167(float[] fArr) { + float[] fArr2 = new float[3]; + if (fArr[0] < this.value109[0]) { + fArr2[0] = this.value109[0]; + } else if (fArr[0] > this.value110[0]) { + fArr2[0] = this.value110[0]; + } else { + fArr2[0] = fArr[0]; + } + if (fArr[1] < this.value109[1]) { + fArr2[1] = this.value109[1]; + } else if (fArr[1] > this.value110[1]) { + fArr2[1] = this.value110[1]; + } else { + fArr2[1] = fArr[1]; + } + if (fArr[2] < this.value109[2]) { + fArr2[2] = this.value109[2]; + } else if (fArr[2] > this.value110[2]) { + fArr2[2] = this.value110[2]; + } else { + fArr2[2] = fArr[2]; + } + return fArr2; + } + + /* renamed from: a */ + public final boolean getBoolean168(float[] fArr, float[] fArr2) { + float f; + float f2; + float f3; + if (fArr[0] < this.value109[0]) { + float f4 = this.value109[0] - fArr[0]; + if (f4 > fArr2[0]) { + return false; + } + f = f4 / fArr2[0]; + } else if (fArr[0] > this.value110[0]) { + float f5 = this.value110[0] - fArr[0]; + if (f5 < fArr2[0]) { + return false; + } + f = f5 / fArr2[0]; + } else { + f = -1.0f; + } + if (fArr[1] < this.value109[1]) { + float f6 = this.value109[1] - fArr[1]; + if (f6 > fArr2[1]) { + return false; + } + f2 = f6 / fArr2[1]; + } else if (fArr[1] > this.value110[1]) { + float f7 = this.value110[1] - fArr[1]; + if (f7 < fArr2[1]) { + return false; + } + f2 = f7 / fArr2[1]; + } else { + f2 = -1.0f; + } + if (fArr[2] < this.value109[2]) { + float f8 = this.value109[2] - fArr[2]; + if (f8 > fArr2[2]) { + return false; + } + f3 = f8 / fArr2[2]; + } else if (fArr[2] > this.value110[2]) { + float f9 = this.value110[2] - fArr[2]; + if (f9 < fArr2[2]) { + return false; + } + f3 = f9 / fArr2[2]; + } else { + f3 = -1.0f; + } + boolean z = false; + float f10 = f; + if (f2 > f10) { + z = true; + f10 = f2; + } + if (f3 > f10) { + z = 2; + f10 = f3; + } + switch (z) { + case false: + float f11 = fArr[1] + (fArr2[1] * f10); + if (f11 >= this.value109[1] && f11 <= this.value110[1]) { + float f12 = fArr[2] + (fArr2[2] * f10); + if (f12 < this.value109[2] || f12 > this.value110[2]) { + } + } + break; + case true: + float f13 = fArr[0] + (fArr2[0] * f10); + if (f13 >= this.value109[0] && f13 <= this.value110[0]) { + float f14 = fArr[2] + (fArr2[2] * f10); + if (f14 < this.value109[2] || f14 > this.value110[2]) { + } + } + break; + case true: + float f15 = fArr[0] + (fArr2[0] * f10); + if (f15 >= this.value109[0] && f15 <= this.value110[0]) { + float f16 = fArr[1] + (fArr2[1] * f10); + if (f16 < this.value109[1] || f16 > this.value110[1]) { + } + } + break; + } + return false; + } +} diff --git a/p000/BillboardSprite.java b/p000/BillboardSprite.java new file mode 100644 index 0000000..2911343 --- /dev/null +++ b/p000/BillboardSprite.java @@ -0,0 +1,67 @@ +package p000; + +import javax.microedition.m3g.Appearance; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.CompositingMode; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.Texture2D; +import javax.microedition.m3g.TriangleStripArray; +import javax.microedition.m3g.VertexArray; +import javax.microedition.m3g.VertexBuffer; + +/* renamed from: am */ +/* loaded from: microcounterstrike.jar:am.class */ +public final class BillboardSprite { + + /* renamed from: a */ + public Mesh mesh75; + + /* renamed from: b */ + private Camera camera76; + + public BillboardSprite(Image2D image2D, Camera camera, float f, float f2, float f3, float f4) { + this.camera76 = camera; + this.mesh75 = new Mesh(getVertexBuffer104(), new TriangleStripArray(new int[]{1, 2, 0, 3}, new int[]{4}), getAppearance105(image2D)); + float f5 = f4 * 0.5f; + this.mesh75.scale(f5, f5, f5); + this.mesh75.setTranslation(f, f2, f3); + this.mesh75.setAlignment(this.camera76, 148, (Node) null, 144); + } + + /* renamed from: b */ + private static VertexBuffer getVertexBuffer104() { + short[] sArr = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0}; + VertexArray vertexArray = new VertexArray(sArr.length / 3, 3, 2); + vertexArray.set(0, sArr.length / 3, sArr); + short[] sArr2 = {0, 1, 1, 1, 1, 0, 0, 0}; + VertexArray vertexArray2 = new VertexArray(sArr2.length / 2, 2, 2); + vertexArray2.set(0, sArr2.length / 2, sArr2); + VertexBuffer vertexBuffer = new VertexBuffer(); + vertexBuffer.setPositions(vertexArray, 1.0f, (float[]) null); + vertexBuffer.setTexCoords(0, vertexArray2, 1.0f, (float[]) null); + return vertexBuffer; + } + + /* renamed from: a */ + private static Appearance getAppearance105(Image2D image2D) { + Appearance appearance = new Appearance(); + CompositingMode compositingMode = new CompositingMode(); + compositingMode.setBlending(64); + appearance.setCompositingMode(compositingMode); + if (image2D != null) { + Texture2D texture2D = new Texture2D(image2D); + texture2D.setFiltering(210, 210); + texture2D.setWrapping(240, 240); + texture2D.setBlending(228); + appearance.setTexture(0, texture2D); + } + return appearance; + } + + /* renamed from: a */ + public final void execute106() { + this.mesh75.align(this.camera76); + } +} diff --git a/p000/BluetoothClientSync.java b/p000/BluetoothClientSync.java new file mode 100644 index 0000000..ef942e9 --- /dev/null +++ b/p000/BluetoothClientSync.java @@ -0,0 +1,238 @@ +package p000; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import javax.microedition.m3g.Transform; + +/* renamed from: m */ +/* loaded from: microcounterstrike.jar:m.class */ +public final class BluetoothClientSync { + + /* renamed from: a */ + private static BluetoothClientSync bluetoothClientSync214; + + /* renamed from: b */ + private NetworkStateCache networkStateCache215 = new NetworkStateCache(); + + private BluetoothClientSync() { + } + + /* renamed from: a */ + public static BluetoothClientSync getInstance() { + if (bluetoothClientSync214 == null) { + bluetoothClientSync214 = new BluetoothClientSync(); + } + return bluetoothClientSync214; + } + + /* renamed from: b */ + public final void sendPacket244() throws Exception { + if (ConnectionManager.getInstance_2() == null || ConnectionManager.getInstance_2().flag171) { + return; + } + DataInputStream dataInputStream = ConnectionManager.getInstance_2().input169; + DataOutputStream dataOutputStream = ConnectionManager.getInstance_2().output170; + try { + dataOutputStream.writeInt(10001); + dataOutputStream.flush(); + if (dataInputStream.readInt() != 20001) { + throw new Exception("Error"); + } + dataOutputStream.writeInt(10004); + dataOutputStream.writeInt(GameSessionLoop.getInstance().sessionState); + dataOutputStream.flush(); + if (GameSessionLoop.getInstance().sessionState == 2) { + dataOutputStream.writeInt(10002); + dataOutputStream.writeInt(GameSessionLoop.getInstance().countdownTask.value11); + dataOutputStream.flush(); + } + PlayerEntityBase abstractC0052u = PlayerManager.getInstance().localPlayer; + PlayerEntityBase abstractC0052uM197a = PlayerManager.getInstance().getPlayerById(2); + LocalPlayer c0008ah = (LocalPlayer) abstractC0052u; + RemotePlayer c0032be = (RemotePlayer) abstractC0052uM197a; + float[] fArrM289i = abstractC0052u.getFloatArray289(); + float[] fArr = this.networkStateCache215.value160; + if (fArrM289i[0] != fArr[0] || fArrM289i[1] != fArr[1] || fArrM289i[2] != fArr[2]) { + dataOutputStream.writeInt(10003); + dataOutputStream.writeFloat(fArrM289i[0]); + dataOutputStream.writeFloat(abstractC0052uM197a.getFloatArray289()[1]); + dataOutputStream.writeFloat(fArrM289i[2]); + float[] fArr2 = abstractC0052u.sphereCollider262.value98; + dataOutputStream.writeFloat(fArr2[0]); + dataOutputStream.writeFloat(fArr2[1]); + dataOutputStream.writeFloat(fArr2[2]); + dataOutputStream.flush(); + fArr[0] = fArrM289i[0]; + fArr[1] = fArrM289i[1]; + fArr[2] = fArrM289i[2]; + } + Transform transform = c0008ah.transform277; + float[] fArr3 = new float[16]; + transform.get(fArr3); + float[] fArr4 = this.networkStateCache215.value162; + if (fArr3[0] != fArr4[0] || fArr3[1] != fArr4[1] || fArr3[2] != fArr4[2] || fArr3[4] != fArr4[3] || fArr3[5] != fArr4[4] || fArr3[6] != fArr4[5] || fArr3[8] != fArr4[6] || fArr3[9] != fArr4[7] || fArr3[10] != fArr4[8]) { + dataOutputStream.writeInt(10008); + dataOutputStream.writeFloat(fArr3[0]); + dataOutputStream.writeFloat(fArr3[1]); + dataOutputStream.writeFloat(fArr3[2]); + dataOutputStream.writeFloat(fArr3[4]); + dataOutputStream.writeFloat(fArr3[5]); + dataOutputStream.writeFloat(fArr3[6]); + dataOutputStream.writeFloat(fArr3[8]); + dataOutputStream.writeFloat(fArr3[9]); + dataOutputStream.writeFloat(fArr3[10]); + dataOutputStream.flush(); + fArr4[0] = fArr3[0]; + fArr4[1] = fArr3[1]; + fArr4[2] = fArr3[2]; + fArr4[3] = fArr3[4]; + fArr4[4] = fArr3[5]; + fArr4[5] = fArr3[6]; + fArr4[6] = fArr3[8]; + fArr4[7] = fArr3[9]; + fArr4[8] = fArr3[10]; + } + Transform transform2 = c0008ah.transform278; + float[] fArr5 = new float[16]; + transform2.get(fArr5); + float[] fArr6 = this.networkStateCache215.value163; + if (fArr5[0] != fArr6[0] || fArr5[1] != fArr6[1] || fArr5[2] != fArr6[2] || fArr5[4] != fArr6[3] || fArr5[5] != fArr6[4] || fArr5[6] != fArr6[5] || fArr5[8] != fArr6[6] || fArr5[9] != fArr6[7] || fArr5[10] != fArr6[8]) { + dataOutputStream.writeInt(10009); + dataOutputStream.writeFloat(fArr5[0]); + dataOutputStream.writeFloat(fArr5[1]); + dataOutputStream.writeFloat(fArr5[2]); + dataOutputStream.writeFloat(fArr5[4]); + dataOutputStream.writeFloat(fArr5[5]); + dataOutputStream.writeFloat(fArr5[6]); + dataOutputStream.writeFloat(fArr5[8]); + dataOutputStream.writeFloat(fArr5[9]); + dataOutputStream.writeFloat(fArr5[10]); + dataOutputStream.flush(); + fArr6[0] = fArr5[0]; + fArr6[1] = fArr5[1]; + fArr6[2] = fArr5[2]; + fArr6[3] = fArr5[4]; + fArr6[4] = fArr5[5]; + fArr6[5] = fArr5[6]; + fArr6[6] = fArr5[8]; + fArr6[7] = fArr5[9]; + fArr6[8] = fArr5[10]; + } + int i = ((RemotePlayer) abstractC0052uM197a).value148; + if (i != this.networkStateCache215.value161) { + dataOutputStream.writeInt(10005); + dataOutputStream.writeInt(i); + this.networkStateCache215.value161 = i; + } + if (((HudRenderer) HudBase.getInstance()).value287 == 0) { + dataOutputStream.writeInt(10006); + dataOutputStream.flush(); + } + if (c0008ah.grenadeController.value57 == 0) { + dataOutputStream.writeInt(10007); + float[] fArrM287a = abstractC0052u.compute287(1, 1.0f); + dataOutputStream.writeFloat(fArrM287a[0]); + dataOutputStream.writeFloat(fArrM287a[1]); + dataOutputStream.writeFloat(fArrM287a[2]); + dataOutputStream.flush(); + } + int i2 = c0008ah.loadout.getActiveWeaponInfo().weaponCode / 10; + if (i2 != this.networkStateCache215.value164) { + dataOutputStream.writeInt(10010); + dataOutputStream.writeInt(i2); + dataOutputStream.flush(); + this.networkStateCache215.value164 = i2; + } + if (((HudRenderer) HudBase.getInstance()).value288 == 0) { + dataOutputStream.writeInt(10011); + dataOutputStream.flush(); + } + dataOutputStream.writeInt(10099); + dataOutputStream.flush(); + boolean z = false; + while (!z) { + switch (dataInputStream.readInt()) { + case 20003: + abstractC0052uM197a.playerModelBase261.node234.setTranslation(dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat()); + float[] fArr7 = abstractC0052uM197a.sphereCollider262.value98; + fArr7[0] = dataInputStream.readFloat(); + fArr7[1] = dataInputStream.readFloat(); + fArr7[2] = dataInputStream.readFloat(); + if (!c0032be.getBoolean258()) { + break; + } else { + c0032be.execute256(1); + break; + } + case 20005: + c0008ah.health = dataInputStream.readInt(); + c0008ah.resetPainSoundCounter(); + if (c0008ah.health > 0) { + break; + } else { + ((RoundBasedGameMode) GameSessionLoop.getInstance()).execute123(abstractC0052u); + break; + } + case 20006: + c0032be.execute206(true); + break; + case 20007: + float[] fArrM289i2 = c0032be.getFloatArray289(); + fArrM289i2[1] = abstractC0052u.getFloatArray289()[1] * 1.4f; + c0032be.grenadeController150.execute73(MapManager.getInstance().world, fArrM289i2, new float[]{dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat()}); + break; + case 20008: + Transform transform3 = c0032be.transform218; + float[] fArr8 = {dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + transform3.get(fArr8); + transform3.set(fArr8); + break; + case 20009: + Transform transform4 = c0032be.transform219; + float[] fArr9 = {dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + transform4.get(fArr9); + transform4.set(fArr9); + break; + case 20010: + int i3 = dataInputStream.readInt(); + c0032be.weaponLoadout149.selectSlot(i3); + PlayerModel c0051t = (PlayerModel) c0032be.playerModelBase261; + c0051t.node244.setRenderingEnable(false); + c0051t.node245.setRenderingEnable(false); + c0051t.node246.setRenderingEnable(false); + c0051t.node247.setRenderingEnable(false); + switch (i3) { + case 1: + c0051t.node244.setRenderingEnable(true); + continue; + case 2: + c0051t.node245.setRenderingEnable(true); + continue; + case 3: + c0051t.node246.setRenderingEnable(true); + continue; + case 4: + c0051t.node247.setRenderingEnable(true); + break; + } + break; + case 20011: + ((PlayerModel) c0032be.playerModelBase261).execute279(); + break; + case 20099: + z = true; + break; + } + Thread.yield(); + } + c0032be.grenadeController150.execute74(MapManager.getInstance().world); + c0032be.execute257(); + ((PlayerModel) c0032be.playerModelBase261).execute280(); + } catch (Exception unused) { + GameSessionLoop.getInstance().sessionState = 5; + MainUiCanvasBase abstractC0037fM227a = MainUiCanvasBase.getInstance(); + abstractC0037fM227a.value181 = 25; + abstractC0037fM227a.execute37(); + } + } +} diff --git a/p000/BluetoothControlChannel.java b/p000/BluetoothControlChannel.java new file mode 100644 index 0000000..2d41c47 --- /dev/null +++ b/p000/BluetoothControlChannel.java @@ -0,0 +1,127 @@ +package p000; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import javax.microedition.io.StreamConnection; + +/* renamed from: av */ +/* loaded from: microcounterstrike.jar:av.class */ +public final class BluetoothControlChannel implements Runnable { + + /* renamed from: c */ + private StreamConnection connection94; + + /* renamed from: a */ + public DataInputStream input95; + + /* renamed from: b */ + public DataOutputStream output96; + + /* renamed from: d */ + private boolean flag97 = true; + + public BluetoothControlChannel(StreamConnection streamConnection) { + this.connection94 = streamConnection; + try { + this.input95 = streamConnection.openDataInputStream(); + this.output96 = streamConnection.openDataOutputStream(); + } catch (IOException unused) { + readPacket136(); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1 */ + /* JADX WARN: Type inference failed for: r0v14 */ + /* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Throwable] */ + @Override // java.lang.Runnable + public final void run() throws InterruptedException { + boolean z = false; + while (true) { + ?? r0 = z; + if (r0 != 0) { + return; + } + try { + try { + r0 = 50; + Thread.sleep(50L); + } catch (InterruptedException e) { + r0.printStackTrace(); + } + MainUiCanvasBase abstractC0037fM227a = MainUiCanvasBase.getInstance(); + switch (this.input95.readInt()) { + case 9002: + MapManager.getInstance().currentMapIndex = this.input95.readInt(); + continue; + case 9003: + abstractC0037fM227a.value181 = 13; + abstractC0037fM227a.execute37(); + GameLoadingThread.getInstance(); + GameLoadingThread.showScreen95(); + continue; + case 9004: + GameSessionLoop.getInstance().start(); + z = true; + continue; + } + } catch (IOException unused) { + readPacket136(); + return; + } + readPacket136(); + return; + } + } + + /* JADX WARN: Type inference failed for: r0v4, types: [java.io.DataOutputStream, java.lang.Throwable] */ + /* renamed from: a */ + public final void sendPacket135() { + ?? r0; + try { + this.output96.writeInt(1002); + r0 = this.output96; + r0.flush(); + } catch (IOException e) { + r0.printStackTrace(); + } + } + + /* renamed from: b */ + public final void readPacket136() { + execute138(); + MainUiCanvasBase abstractC0037fM227a = MainUiCanvasBase.getInstance(); + abstractC0037fM227a.value181 = 25; + abstractC0037fM227a.execute37(); + } + + /* renamed from: c */ + public final void execute137() { + if (this.flag97) { + new Thread(this).start(); + this.flag97 = false; + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1, types: [boolean] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v9, types: [javax.microedition.io.Connection, javax.microedition.io.StreamConnection] */ + /* renamed from: d */ + public final void execute138() { + ?? r0 = this.flag97; + if (r0 != 0) { + return; + } + try { + this.flag97 = true; + this.input95.close(); + this.output96.close(); + r0 = this.connection94; + r0.close(); + } catch (IOException e) { + r0.printStackTrace(); + } + } +} diff --git a/p000/BluetoothDiscoveryClient.java b/p000/BluetoothDiscoveryClient.java new file mode 100644 index 0000000..1144cc6 --- /dev/null +++ b/p000/BluetoothDiscoveryClient.java @@ -0,0 +1,238 @@ +package p000; + +import java.util.Vector; +import javax.bluetooth.BluetoothStateException; +import javax.bluetooth.DeviceClass; +import javax.bluetooth.DiscoveryAgent; +import javax.bluetooth.DiscoveryListener; +import javax.bluetooth.LocalDevice; +import javax.bluetooth.RemoteDevice; +import javax.bluetooth.ServiceRecord; +import javax.bluetooth.UUID; +import javax.microedition.io.Connector; + +/* renamed from: p */ +/* loaded from: microcounterstrike.jar:p.class */ +public final class BluetoothDiscoveryClient implements Runnable, DiscoveryListener { + + /* renamed from: c */ + private static BluetoothDiscoveryClient bluetoothDiscoveryClient224; + + /* renamed from: d */ + private DiscoveryAgent discoveryAgent225; + + /* renamed from: e */ + private UUID[] uUIDArr226; + + /* renamed from: f */ + private static final UUID CONST_UUID227 = new UUID("F0E0D0C0B0A000908070605040302010", false); + + /* renamed from: g */ + private int[] value228; + + /* renamed from: h */ + private Vector list229; + + /* renamed from: a */ + public Vector list230; + + /* renamed from: i */ + private int value231; + + /* renamed from: j */ + private int value232; + + /* renamed from: b */ + public BluetoothControlChannel bluetoothControlChannel233; + + private BluetoothDiscoveryClient() { + } + + /* renamed from: a */ + public static BluetoothDiscoveryClient getInstance() { + if (bluetoothDiscoveryClient224 == null) { + bluetoothDiscoveryClient224 = new BluetoothDiscoveryClient(); + } + return bluetoothDiscoveryClient224; + } + + /* renamed from: b */ + public final void execute267() { + execute268(); + this.value231 = 0; + new Thread(this).start(); + } + + /* renamed from: c */ + private void execute268() { + this.list229 = new Vector(); + this.list230 = new Vector(); + } + + /* renamed from: a */ + public final void execute269(int i) { + this.value231 = 1; + this.value232 = i; + new Thread(this).start(); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v20, types: [f] */ + /* JADX WARN: Type inference failed for: r0v21 */ + /* JADX WARN: Type inference failed for: r0v22, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v27, types: [javax.bluetooth.UUID[]] */ + /* JADX WARN: Type inference failed for: r0v28 */ + /* JADX WARN: Type inference failed for: r0v29 */ + /* JADX WARN: Type inference failed for: r0v30, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v38 */ + /* JADX WARN: Type inference failed for: r0v39, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v4, types: [int] */ + /* JADX WARN: Type inference failed for: r0v40, types: [java.lang.Object] */ + /* JADX WARN: Type inference failed for: r0v47, types: [java.lang.Object] */ + /* JADX WARN: Type inference failed for: r0v5 */ + /* JADX WARN: Type inference failed for: r0v50, types: [boolean] */ + /* JADX WARN: Type inference failed for: r0v52, types: [p] */ + /* JADX WARN: Type inference failed for: r0v53 */ + /* JADX WARN: Type inference failed for: r0v54 */ + @Override // java.lang.Runnable + public final synchronized void run() throws InterruptedException { + ?? r0; + ?? r02; + MainUiCanvasBase abstractC0037fM227a = MainUiCanvasBase.getInstance(); + if (this.value231 != 0) { + ?? r03 = this.value231; + if (r03 == 1) { + try { + BluetoothControlChannel runnableC0022av = new BluetoothControlChannel(Connector.open(((ServiceRecord) this.list230.elementAt(this.value232)).getConnectionURL(0, false))); + runnableC0022av.execute137(); + this.bluetoothControlChannel233 = runnableC0022av; + abstractC0037fM227a.value181 = 24; + r03 = abstractC0037fM227a; + r03.execute37(); + return; + } catch (Exception e) { + if (r03 instanceof SecurityException) { + execute270(); + return; + } + return; + } + } + return; + } + ?? r04 = 0; + try { + r04 = this; + r04.discoveryAgent225 = LocalDevice.getLocalDevice().getDiscoveryAgent(); + } catch (Exception e2) { + r04.printStackTrace(); + } + this.uUIDArr226 = new UUID[2]; + this.uUIDArr226[0] = new UUID(4353L); + ?? StartInquiry = this.uUIDArr226; + StartInquiry[1] = CONST_UUID227; + try { + StartInquiry = this.discoveryAgent225.startInquiry(10390323, this); + r0 = StartInquiry; + } catch (BluetoothStateException unused) { + r0 = StartInquiry; + } + try { + r0 = this; + r0.wait(); + } catch (InterruptedException e3) { + r0.printStackTrace(); + } + if (this.list229.size() > 0) { + this.value228 = new int[this.list229.size()]; + int i = 0; + while (true) { + r02 = i; + if (r02 >= this.list229.size()) { + try { + break; + } catch (InterruptedException e4) { + r02.printStackTrace(); + } + } else { + try { + this.value228[i] = this.discoveryAgent225.searchServices((int[]) null, this.uUIDArr226, (RemoteDevice) this.list229.elementAt(i), this); + } catch (BluetoothStateException unused2) { + } + i++; + } + } + r02 = this; + r02.wait(); + } + abstractC0037fM227a.value181 = 22; + abstractC0037fM227a.execute37(); + } + + /* renamed from: d */ + private static void execute270() { + MainUiCanvasBase.getInstance().value181 = 14; + MainUiCanvasBase.getInstance().execute37(); + } + + public final void deviceDiscovered(RemoteDevice remoteDevice, DeviceClass deviceClass) { + if (this.list229.indexOf(remoteDevice) == -1) { + this.list229.addElement(remoteDevice); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0 */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v3 */ + public final void inquiryCompleted(int i) { + ?? r0 = this; + synchronized (r0) { + notify(); + r0 = r0; + } + } + + public final void servicesDiscovered(int i, ServiceRecord[] serviceRecordArr) { + for (ServiceRecord serviceRecord : serviceRecordArr) { + this.list230.addElement(serviceRecord); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v6 */ + /* JADX WARN: Type inference failed for: r0v7, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v9 */ + public final void serviceSearchCompleted(int i, int i2) { + int i3 = 0; + while (true) { + if (i3 >= this.value228.length) { + break; + } + if (this.value228[i3] == i) { + this.value228[i3] = -1; + break; + } + i3++; + } + boolean z = true; + int i4 = 0; + while (true) { + if (i4 >= this.value228.length) { + break; + } + if (this.value228[i4] != -1) { + z = false; + break; + } + i4++; + } + if (z) { + ?? r0 = this; + synchronized (r0) { + notify(); + r0 = r0; + } + } + } +} diff --git a/p000/BluetoothHostSync.java b/p000/BluetoothHostSync.java new file mode 100644 index 0000000..a8bafaa --- /dev/null +++ b/p000/BluetoothHostSync.java @@ -0,0 +1,254 @@ +package p000; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import javax.microedition.m3g.Transform; + +/* renamed from: al */ +/* loaded from: microcounterstrike.jar:al.class */ +public final class BluetoothHostSync { + + /* renamed from: a */ + private static BluetoothHostSync bluetoothHostSync73; + + /* renamed from: b */ + private NetworkStateCache networkStateCache74 = new NetworkStateCache(); + + private BluetoothHostSync() { + } + + /* renamed from: a */ + public static BluetoothHostSync getInstance() { + if (bluetoothHostSync73 == null) { + bluetoothHostSync73 = new BluetoothHostSync(); + } + return bluetoothHostSync73; + } + + /* renamed from: b */ + public final void sendPacket103() throws Exception { + DataInputStream dataInputStream = BluetoothDiscoveryClient.getInstance().bluetoothControlChannel233.input95; + DataOutputStream dataOutputStream = BluetoothDiscoveryClient.getInstance().bluetoothControlChannel233.output96; + GameSessionLoop abstractRunnableC0014anM107a = GameSessionLoop.getInstance(); + try { + if (dataInputStream.readInt() != 10001) { + throw new Exception("Error"); + } + dataOutputStream.writeInt(20001); + dataOutputStream.flush(); + PlayerEntityBase abstractC0052u = PlayerManager.getInstance().localPlayer; + PlayerEntityBase abstractC0052uM197a = PlayerManager.getInstance().getPlayerById(2); + LocalPlayer c0008ah = (LocalPlayer) abstractC0052u; + RemotePlayer c0032be = (RemotePlayer) abstractC0052uM197a; + float[] fArrM289i = abstractC0052u.getFloatArray289(); + float[] fArr = this.networkStateCache74.value160; + if (fArrM289i[0] != fArr[0] || fArrM289i[1] != fArr[1] || fArrM289i[2] != fArr[2]) { + dataOutputStream.writeInt(20003); + dataOutputStream.writeFloat(fArrM289i[0]); + dataOutputStream.writeFloat(abstractC0052uM197a.getFloatArray289()[1]); + dataOutputStream.writeFloat(fArrM289i[2]); + float[] fArr2 = abstractC0052u.sphereCollider262.value98; + dataOutputStream.writeFloat(fArr2[0]); + dataOutputStream.writeFloat(fArr2[1]); + dataOutputStream.writeFloat(fArr2[2]); + dataOutputStream.flush(); + fArr[0] = fArrM289i[0]; + fArr[1] = fArrM289i[1]; + fArr[2] = fArrM289i[2]; + } + int i = ((RemotePlayer) abstractC0052uM197a).value148; + if (i != this.networkStateCache74.value161) { + dataOutputStream.writeInt(20005); + dataOutputStream.writeInt(i); + this.networkStateCache74.value161 = i; + } + if (((HudRenderer) HudBase.getInstance()).value287 == 0) { + dataOutputStream.writeInt(20006); + dataOutputStream.flush(); + } + if (c0008ah.grenadeController.value57 == 0) { + dataOutputStream.writeInt(20007); + float[] fArrM287a = abstractC0052u.compute287(1, 1.0f); + dataOutputStream.writeFloat(fArrM287a[0]); + dataOutputStream.writeFloat(fArrM287a[1]); + dataOutputStream.writeFloat(fArrM287a[2]); + dataOutputStream.flush(); + } + Transform transform = c0008ah.transform277; + float[] fArr3 = new float[16]; + transform.get(fArr3); + float[] fArr4 = this.networkStateCache74.value162; + if (fArr3[0] != fArr4[0] || fArr3[1] != fArr4[1] || fArr3[2] != fArr4[2] || fArr3[4] != fArr4[3] || fArr3[5] != fArr4[4] || fArr3[6] != fArr4[5] || fArr3[8] != fArr4[6] || fArr3[9] != fArr4[7] || fArr3[10] != fArr4[8]) { + dataOutputStream.writeInt(20008); + dataOutputStream.writeFloat(fArr3[0]); + dataOutputStream.writeFloat(fArr3[1]); + dataOutputStream.writeFloat(fArr3[2]); + dataOutputStream.writeFloat(fArr3[4]); + dataOutputStream.writeFloat(fArr3[5]); + dataOutputStream.writeFloat(fArr3[6]); + dataOutputStream.writeFloat(fArr3[8]); + dataOutputStream.writeFloat(fArr3[9]); + dataOutputStream.writeFloat(fArr3[10]); + dataOutputStream.flush(); + fArr4[0] = fArr3[0]; + fArr4[1] = fArr3[1]; + fArr4[2] = fArr3[2]; + fArr4[3] = fArr3[4]; + fArr4[4] = fArr3[5]; + fArr4[5] = fArr3[6]; + fArr4[6] = fArr3[8]; + fArr4[7] = fArr3[9]; + fArr4[8] = fArr3[10]; + } + Transform transform2 = c0008ah.transform278; + float[] fArr5 = new float[16]; + transform2.get(fArr5); + float[] fArr6 = this.networkStateCache74.value163; + if (fArr5[0] != fArr6[0] || fArr5[1] != fArr6[1] || fArr5[2] != fArr6[2] || fArr5[4] != fArr6[3] || fArr5[5] != fArr6[4] || fArr5[6] != fArr6[5] || fArr5[8] != fArr6[6] || fArr5[9] != fArr6[7] || fArr5[10] != fArr6[8]) { + dataOutputStream.writeInt(20009); + dataOutputStream.writeFloat(fArr5[0]); + dataOutputStream.writeFloat(fArr5[1]); + dataOutputStream.writeFloat(fArr5[2]); + dataOutputStream.writeFloat(fArr5[4]); + dataOutputStream.writeFloat(fArr5[5]); + dataOutputStream.writeFloat(fArr5[6]); + dataOutputStream.writeFloat(fArr5[8]); + dataOutputStream.writeFloat(fArr5[9]); + dataOutputStream.writeFloat(fArr5[10]); + dataOutputStream.flush(); + fArr6[0] = fArr5[0]; + fArr6[1] = fArr5[1]; + fArr6[2] = fArr5[2]; + fArr6[3] = fArr5[4]; + fArr6[4] = fArr5[5]; + fArr6[5] = fArr5[6]; + fArr6[6] = fArr5[8]; + fArr6[7] = fArr5[9]; + fArr6[8] = fArr5[10]; + } + int i2 = c0008ah.loadout.getActiveWeaponInfo().weaponCode / 10; + if (i2 != this.networkStateCache74.value164) { + dataOutputStream.writeInt(20010); + dataOutputStream.writeInt(i2); + dataOutputStream.flush(); + this.networkStateCache74.value164 = i2; + } + if (((HudRenderer) HudBase.getInstance()).value288 == 0) { + dataOutputStream.writeInt(20011); + dataOutputStream.flush(); + } + dataOutputStream.writeInt(20099); + dataOutputStream.flush(); + boolean z = false; + while (!z) { + switch (dataInputStream.readInt()) { + case 10002: + int i3 = dataInputStream.readInt(); + if (GameSessionLoop.getInstance().sessionState != 2) { + break; + } else { + abstractRunnableC0014anM107a.countdownTask.value11 = i3; + break; + } + case 10003: + abstractC0052uM197a.playerModelBase261.node234.setTranslation(dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat()); + float[] fArr7 = abstractC0052uM197a.sphereCollider262.value98; + fArr7[0] = dataInputStream.readFloat(); + fArr7[1] = dataInputStream.readFloat(); + fArr7[2] = dataInputStream.readFloat(); + if (!c0032be.getBoolean258()) { + break; + } else { + c0032be.execute256(1); + break; + } + case 10004: + int i4 = dataInputStream.readInt(); + if (i4 != abstractRunnableC0014anM107a.sessionState && abstractRunnableC0014anM107a.sessionState != 5) { + if (i4 != 2) { + if (i4 != 3 || abstractRunnableC0014anM107a.sessionState != 2 || abstractRunnableC0014anM107a.countdownTask.value11 == 0) { + break; + } else { + abstractRunnableC0014anM107a.countdownTask.value11 = 0; + break; + } + } else { + abstractRunnableC0014anM107a.sessionState = 2; + abstractRunnableC0014anM107a.countdownTask = null; + abstractRunnableC0014anM107a.countdownTask = new CountdownTimerTask(0); + break; + } + } else { + break; + } + break; + case 10005: + c0008ah.health = dataInputStream.readInt(); + c0008ah.resetPainSoundCounter(); + if (c0008ah.health > 0) { + break; + } else { + ((RoundBasedGameMode) GameSessionLoop.getInstance()).execute123(abstractC0052u); + break; + } + case 10006: + c0032be.execute206(true); + break; + case 10007: + float[] fArrM289i2 = c0032be.getFloatArray289(); + fArrM289i2[1] = abstractC0052u.getFloatArray289()[1] * 1.4f; + c0032be.grenadeController150.execute73(MapManager.getInstance().world, fArrM289i2, new float[]{dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat()}); + break; + case 10008: + Transform transform3 = c0032be.transform218; + float[] fArr8 = {dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + transform3.get(fArr8); + transform3.set(fArr8); + break; + case 10009: + Transform transform4 = c0032be.transform219; + float[] fArr9 = {dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, dataInputStream.readFloat(), dataInputStream.readFloat(), dataInputStream.readFloat(), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + transform4.get(fArr9); + transform4.set(fArr9); + break; + case 10010: + int i5 = dataInputStream.readInt(); + c0032be.weaponLoadout149.selectSlot(i5); + PlayerModel c0051t = (PlayerModel) c0032be.playerModelBase261; + c0051t.node244.setRenderingEnable(false); + c0051t.node245.setRenderingEnable(false); + c0051t.node246.setRenderingEnable(false); + c0051t.node247.setRenderingEnable(false); + switch (i5) { + case 1: + c0051t.node244.setRenderingEnable(true); + break; + case 2: + c0051t.node245.setRenderingEnable(true); + break; + case 3: + c0051t.node246.setRenderingEnable(true); + break; + case 4: + c0051t.node247.setRenderingEnable(true); + break; + } + break; + case 10011: + ((PlayerModel) c0032be.playerModelBase261).execute279(); + break; + case 10099: + z = true; + break; + } + Thread.yield(); + } + c0032be.grenadeController150.execute74(MapManager.getInstance().world); + c0032be.execute257(); + ((PlayerModel) c0032be.playerModelBase261).execute280(); + } catch (Exception unused) { + abstractRunnableC0014anM107a.sessionState = 5; + BluetoothDiscoveryClient.getInstance().bluetoothControlChannel233.readPacket136(); + } + } +} diff --git a/p000/BluetoothServerListener.java b/p000/BluetoothServerListener.java new file mode 100644 index 0000000..4e7a2e0 --- /dev/null +++ b/p000/BluetoothServerListener.java @@ -0,0 +1,120 @@ +package p000; + +import java.io.IOException; +import javax.bluetooth.LocalDevice; +import javax.bluetooth.UUID; +import javax.microedition.io.Connector; +import javax.microedition.io.StreamConnection; +import javax.microedition.io.StreamConnectionNotifier; + +/* renamed from: ba */ +/* loaded from: microcounterstrike.jar:ba.class */ +public final class BluetoothServerListener implements Runnable { + + /* renamed from: a */ + private static BluetoothServerListener bluetoothServerListener129; + + /* renamed from: b */ + private StreamConnectionNotifier streamConnectionNotifier130; + + /* renamed from: c */ + private static final UUID CONST_UUID131 = new UUID("F0E0D0C0B0A000908070605040302010", false); + + /* renamed from: d */ + private boolean flag132; + + private BluetoothServerListener() { + this.flag132 = true; + this.flag132 = true; + } + + /* renamed from: a */ + public static BluetoothServerListener getInstance() { + bluetoothServerListener129 = new BluetoothServerListener(); + return bluetoothServerListener129; + } + + /* renamed from: b */ + public static BluetoothServerListener getInstance_2() { + return bluetoothServerListener129; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v14 */ + /* JADX WARN: Type inference failed for: r0v4, types: [boolean] */ + /* JADX WARN: Type inference failed for: r0v5, types: [java.lang.Throwable] */ + @Override // java.lang.Runnable + public final void run() throws InterruptedException { + StreamConnection streamConnectionAcceptAndOpen; + try { + LocalDevice.getLocalDevice().setDiscoverable(10390323); + StringBuffer stringBuffer = new StringBuffer("btspp://"); + stringBuffer.append("localhost").append(':'); + stringBuffer.append(CONST_UUID131.toString()); + stringBuffer.append(";name="); + stringBuffer.append("BT Server"); + stringBuffer.append(";authorize=false"); + this.streamConnectionNotifier130 = Connector.open(stringBuffer.toString()); + } catch (Exception e) { + System.out.println("ERROR!!!"); + if (e instanceof SecurityException) { + execute188(); + return; + } + } + while (true) { + ?? r0 = this.flag132; + if (r0 != 0) { + return; + } + try { + r0 = 500; + Thread.sleep(500L); + } catch (InterruptedException e2) { + r0.printStackTrace(); + } + try { + streamConnectionAcceptAndOpen = this.streamConnectionNotifier130.acceptAndOpen(); + } catch (IOException unused) { + } + if (this.flag132) { + return; + } + ConnectionManager.getInstance(streamConnectionAcceptAndOpen); + ConnectionManager.getInstance_2().execute222(); + } + } + + /* renamed from: e */ + private static void execute188() { + MainUiCanvasBase.getInstance().value181 = 14; + MainUiCanvasBase.getInstance().execute37(); + } + + /* renamed from: c */ + public final void execute189() { + if (this.flag132) { + new Thread(this).start(); + this.flag132 = false; + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v2, types: [ba] */ + /* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v5, types: [javax.microedition.io.Connection, javax.microedition.io.StreamConnectionNotifier] */ + /* renamed from: d */ + public final void execute190() { + if (this.flag132) { + return; + } + ?? r0 = this; + r0.flag132 = true; + try { + r0 = this.streamConnectionNotifier130; + r0.close(); + } catch (IOException e) { + r0.printStackTrace(); + } + } +} diff --git a/p000/BotAIController.java b/p000/BotAIController.java new file mode 100644 index 0000000..859f37c --- /dev/null +++ b/p000/BotAIController.java @@ -0,0 +1,83 @@ +package p000; + +/* renamed from: r */ +/* loaded from: microcounterstrike.jar:r.class */ +public class BotAIController extends AiControllerBase { + /* JADX WARN: Removed duplicated region for block: B:37:0x009c */ + @Override // p000.AiControllerBase + /* renamed from: a */ + /* + Code decompiled incorrectly, please refer to instructions dump. + To view partially-correct code enable 'Show inconsistent code' option in preferences + */ + public final void execute115(p000.PlayerEntityBase r5) { + /* + Method dump skipped, instructions count: 204 + To view this dump change 'Code comments level' option to 'DEBUG' + */ + throw new UnsupportedOperationException("Method not decompiled: p000.BotAIController.execute115(u):void"); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* renamed from: a */ + private boolean getBoolean274(PlayerEntityBase abstractC0052u, int i) { + Combatant interfaceC0030bc = (Combatant) abstractC0052u; + execute275(abstractC0052u); + if (i == 1) { + abstractC0052u.getFloat248(0.1f); + } else { + abstractC0052u.getFloat249(0.3f); + } + if (MainUiCanvasBase.getInstance().soundEnabled) { + int i2 = interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode; + if (i2 == 10) { + SoundManager.getInstance().execute199(1); + } else if (i2 == 11) { + SoundManager.getInstance().execute199(2); + } else if (i2 == 20) { + SoundManager.getInstance().execute199(3); + } + } + interfaceC0030bc.handleAction(); + return true; + } + + /* renamed from: c */ + private static void execute275(PlayerEntityBase abstractC0052u) { + PlayerEntityBase abstractC0052u2 = PlayerManager.getInstance().localPlayer; + float[] fArrM289i = abstractC0052u.getFloatArray289(); + float[] fArrM289i2 = abstractC0052u2.getFloatArray289(); + float[] fArr = {fArrM289i2[0] - fArrM289i[0], 0.0f, fArrM289i2[2] - fArrM289i[2]}; + float[] fArrM287a = abstractC0052u.compute287(1, 3.0f); + float degrees = (float) Math.toDegrees((float) FastAcos.getDouble78(VectorMath.getFloat259(fArrM287a, fArr) / (Math.sqrt(((fArrM287a[0] * fArrM287a[0]) + (fArrM287a[1] * fArrM287a[1])) + (fArrM287a[2] * fArrM287a[2])) * Math.sqrt(((fArr[0] * fArr[0]) + (fArr[1] * fArr[1])) + (fArr[2] * fArr[2]))))); + if (VectorMath.getFloatArray260(fArrM287a, fArr)[1] < 0.0f) { + abstractC0052u.getFloat251(degrees); + } else { + abstractC0052u.getFloat250(degrees); + } + } + + /* renamed from: a */ + private static void execute276(NetworkPlayerEntity c0045n) { + int iNextInt = RandomUtil.random237.nextInt(25); + if (iNextInt % 2 == 0) { + c0045n.getFloat250(iNextInt); + } else { + c0045n.getFloat251(iNextInt); + } + } + + /* renamed from: b */ + private static void execute277(NetworkPlayerEntity c0045n) { + float[] fArrM287a = c0045n.compute287(1, 3.0f); + SphereCollider c0023awM283c = c0045n.getSphereCollider283(fArrM287a); + float[] fArrM247a = c0045n.getFloatArray247(fArrM287a); + if (c0045n.findHitTarget(c0023awM283c) == null && fArrM247a[0] == fArrM287a[0] && fArrM247a[1] == fArrM287a[1] && fArrM247a[2] == fArrM287a[2]) { + c0045n.execute252(1, fArrM247a); + } else if (RandomUtil.random237.nextInt(2) == 0) { + c0045n.getFloat250(70.0f); + } else { + c0045n.getFloat251(70.0f); + } + } +} diff --git a/p000/BulletHoleManager.java b/p000/BulletHoleManager.java new file mode 100644 index 0000000..43caf8a --- /dev/null +++ b/p000/BulletHoleManager.java @@ -0,0 +1,134 @@ +package p000; + +import java.util.Vector; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.Texture2D; +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.World; + +/* renamed from: x */ +/* loaded from: microcounterstrike.jar:x.class */ +public final class BulletHoleManager { + + /* renamed from: a */ + private static BulletHoleManager bulletHoleManager280; + + /* renamed from: b */ + private static Mesh mesh281; + + /* renamed from: e */ + private static Texture2D[] texture284; + + /* renamed from: g */ + private Vector list286; + + /* renamed from: c */ + private static float value282 = 0.1f; + + /* renamed from: d */ + private static float value283 = 1.0f; + + /* renamed from: f */ + private static float[] value285 = {0.0f, 0.0f, 1.0f}; + + private BulletHoleManager() { + } + + /* renamed from: a */ + public static BulletHoleManager getInstance() { + if (bulletHoleManager280 == null) { + bulletHoleManager280 = new BulletHoleManager(); + } + return bulletHoleManager280; + } + + /* renamed from: a */ + public static void execute303(World world) { + StringBuffer stringBuffer = new StringBuffer("/res/image2d/crater"); + stringBuffer.append(0); + stringBuffer.append(".png"); + mesh281 = ResourceLoader.loadM3G(stringBuffer.toString(), 160); + mesh281.scale(0.5f, 0.5f, 0.5f); + texture284 = new Texture2D[1]; + texture284[0] = mesh281.getAppearance(0).getTexture(0); + world.addChild(mesh281); + mesh281.setPickingEnable(false); + Transform transform = new Transform(); + mesh281.getTransformTo(world, transform); + world.removeChild(mesh281); + float[] fArr = {0.0f, 0.0f, 1.0f, 0.0f}; + transform.transform(fArr); + value285[0] = fArr[0]; + value285[1] = fArr[1]; + value285[2] = fArr[2]; + } + + /* renamed from: a */ + public final void compute304(int i, RayIntersection rayIntersection, World world) { + float distance = rayIntersection.getDistance(); + float[] fArr = new float[6]; + rayIntersection.getRay(fArr); + float f = fArr[0] + (fArr[3] * distance); + float f2 = fArr[1] + (fArr[4] * distance); + float f3 = fArr[2] + (fArr[5] * distance); + float normalX = rayIntersection.getNormalX(); + float normalY = rayIntersection.getNormalY(); + float normalZ = rayIntersection.getNormalZ(); + Node intersected = rayIntersection.getIntersected(); + Transform transform = new Transform(); + intersected.getTransformTo(world, transform); + float[] fArr2 = {normalX, normalY, normalZ, 0.0f}; + transform.transform(fArr2); + float[] fArr3 = {fArr2[0], fArr2[1], fArr2[2]}; + if (VectorMath.getFloat259(fArr3, new float[]{fArr[3], fArr[4], fArr[5]}) > 0.0f) { + fArr3[0] = -fArr3[0]; + fArr3[1] = -fArr3[1]; + fArr3[2] = -fArr3[2]; + } + float degrees = (float) Math.toDegrees((float) FastAcos.getDouble78(VectorMath.getFloat259(value285, fArr3) / (Math.sqrt(((value285[0] * value285[0]) + (value285[1] * value285[1])) + (value285[2] * value285[2])) * Math.sqrt(((fArr3[0] * fArr3[0]) + (fArr3[1] * fArr3[1])) + (fArr3[2] * fArr3[2]))))); + float[] fArrM260b = VectorMath.getFloatArray260(value285, fArr3); + if (fArrM260b[0] == 0.0f && fArrM260b[1] == 0.0f && fArrM260b[2] == 0.0f) { + fArrM260b[1] = 1.0f; + } + float f4 = value282; + if (i == 2) { + f4 = value283; + } + Mesh meshDuplicate = mesh281.duplicate(); + meshDuplicate.setTranslation(f, f2, f3); + meshDuplicate.setScale(f4, f4, f4); + if (fArrM260b[0] != 0.0f || fArrM260b[1] != 0.0f || fArrM260b[2] != 0.0f) { + meshDuplicate.postRotate(degrees, fArrM260b[0], fArrM260b[1], fArrM260b[2]); + } + world.addChild(meshDuplicate); + if (this.list286 == null) { + this.list286 = new Vector(); + } + this.list286.addElement(meshDuplicate); + } + + /* renamed from: b */ + public final void execute305(World world) { + if (this.list286 != null) { + for (int i = 0; i < this.list286.size(); i++) { + world.removeChild((Mesh) this.list286.elementAt(i)); + } + } + this.list286 = null; + this.list286 = new Vector(); + } + + /* renamed from: b */ + public final void execute306() { + this.list286 = null; + } + + /* renamed from: c */ + public static void execute307() { + mesh281 = null; + texture284 = null; + value285 = null; + } +} diff --git a/p000/CameraManager.java b/p000/CameraManager.java new file mode 100644 index 0000000..8f9975a --- /dev/null +++ b/p000/CameraManager.java @@ -0,0 +1,67 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import javax.microedition.m3g.Camera; + +/* renamed from: aq */ +/* loaded from: microcounterstrike.jar:aq.class */ +public final class CameraManager { + + /* renamed from: b */ + private static CameraManager cameraManager87; + + /* renamed from: c */ + private Hashtable map88 = null; + + /* renamed from: a */ + public Camera camera89; + + private CameraManager() { + } + + /* renamed from: a */ + public static CameraManager getInstance() { + if (cameraManager87 == null) { + cameraManager87 = new CameraManager(); + } + return cameraManager87; + } + + /* renamed from: b */ + public final void execute118() { + this.map88 = new Hashtable(); + PlatformServices.getInstance().initCameras(); + } + + /* renamed from: c */ + public final void execute119() { + Enumeration enumerationKeys = this.map88.keys(); + while (enumerationKeys.hasMoreElements()) { + this.map88.get((String) enumerationKeys.nextElement()); + } + this.map88 = null; + } + + /* renamed from: a */ + public final void execute120(String str, Camera camera) { + this.map88.put(str, camera); + } + + /* renamed from: a */ + public final Camera getCamera121(String str) { + Object obj = this.map88.get(str); + if (obj == null) { + return null; + } + return (Camera) obj; + } + + /* renamed from: a */ + public final void execute122(Camera camera, GameRenderCanvas c0002ab) { + this.camera89 = camera; + float width = c0002ab.getWidth() / c0002ab.getHeight(); + camera.setPerspective(60.0f / width, width, 0.1f, 1000.0f); + MapManager.getInstance().world.setActiveCamera(camera); + } +} diff --git a/p000/Combatant.java b/p000/Combatant.java new file mode 100644 index 0000000..f2fe99e --- /dev/null +++ b/p000/Combatant.java @@ -0,0 +1,26 @@ +package p000; + +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.World; + +/* renamed from: bc */ +/* loaded from: microcounterstrike.jar:bc.class */ +public interface Combatant { + /* renamed from: m */ + int getTeamId(); + + /* renamed from: e */ + int handleAction(); + + /* renamed from: a */ + int onHit(PlayerEntityBase abstractC0052u, int i, RayIntersection rayIntersection, World world); + + /* renamed from: j */ + int getHealth(); + + /* renamed from: k */ + WeaponLoadout getLoadout(); + + /* renamed from: l */ + GrenadeController getGrenadeController(); +} diff --git a/p000/ConnectionManager.java b/p000/ConnectionManager.java new file mode 100644 index 0000000..bd94c94 --- /dev/null +++ b/p000/ConnectionManager.java @@ -0,0 +1,108 @@ +package p000; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import javax.microedition.io.StreamConnection; + +/* renamed from: d */ +/* loaded from: microcounterstrike.jar:d.class */ +public final class ConnectionManager { + + /* renamed from: d */ + private static ConnectionManager connectionManager167; + + /* renamed from: e */ + private StreamConnection connection168; + + /* renamed from: a */ + public DataInputStream input169; + + /* renamed from: b */ + public DataOutputStream output170; + + /* renamed from: c */ + public boolean flag171 = true; + + /* renamed from: a */ + public static ConnectionManager getInstance(StreamConnection streamConnection) { + connectionManager167 = null; + connectionManager167 = new ConnectionManager(streamConnection); + return connectionManager167; + } + + /* renamed from: a */ + public static ConnectionManager getInstance_2() { + return connectionManager167; + } + + /* renamed from: b */ + public static void execute217() { + connectionManager167 = null; + } + + private ConnectionManager(StreamConnection streamConnection) { + this.connection168 = streamConnection; + try { + this.input169 = new DataInputStream(streamConnection.openInputStream()); + this.output170 = new DataOutputStream(streamConnection.openOutputStream()); + execute219(); + } catch (IOException e) { + execute218(); + e.printStackTrace(); + } + } + + /* renamed from: g */ + private void execute218() { + sendPacket223(); + } + + /* renamed from: h */ + private void execute219() throws IOException { + this.output170.writeInt(9002); + this.output170.writeInt(MapManager.getInstance().currentMapIndex); + this.output170.flush(); + } + + /* renamed from: c */ + public final void sendPacket220() throws IOException { + this.output170.writeInt(9003); + this.output170.flush(); + } + + /* renamed from: d */ + public final void sendPacket221() throws IOException { + this.output170.writeInt(9004); + this.output170.flush(); + } + + /* renamed from: e */ + public final void execute222() { + if (this.flag171) { + this.flag171 = false; + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1, types: [boolean] */ + /* JADX WARN: Type inference failed for: r0v10, types: [d] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* renamed from: f */ + public final void sendPacket223() { + ?? r0 = this.flag171; + if (r0 != 0) { + return; + } + try { + this.flag171 = true; + this.input169.close(); + this.output170.close(); + this.connection168.close(); + r0 = this; + r0.connection168 = null; + } catch (IOException e) { + r0.printStackTrace(); + } + } +} diff --git a/p000/CountdownTimerTask.java b/p000/CountdownTimerTask.java new file mode 100644 index 0000000..78da2b7 --- /dev/null +++ b/p000/CountdownTimerTask.java @@ -0,0 +1,23 @@ +package p000; + +import java.util.TimerTask; + +/* renamed from: ac */ +/* loaded from: microcounterstrike.jar:ac.class */ +public final class CountdownTimerTask extends TimerTask { + + /* renamed from: a */ + public int value11; + + public CountdownTimerTask(int i) { + this.value11 = i + 1; + } + + @Override // java.util.TimerTask, java.lang.Runnable + public final void run() { + this.value11--; + if (this.value11 == 0) { + cancel(); + } + } +} diff --git a/p000/DefaultPlatformServices.java b/p000/DefaultPlatformServices.java new file mode 100644 index 0000000..056410b --- /dev/null +++ b/p000/DefaultPlatformServices.java @@ -0,0 +1,949 @@ +package p000; + +import javax.microedition.m3g.Camera; + +/* renamed from: ax */ +/* loaded from: microcounterstrike.jar:ax.class */ +public class DefaultPlatformServices extends PlatformServices { + + /* renamed from: b */ + public static Class cachedGameplayCanvasClass; + + /* renamed from: c */ + public static Class cachedGameModeClass; + + /* renamed from: d */ + public static Class cachedMainMenuCanvasClass; + + /* renamed from: e */ + public static Class cachedHudRendererClass; + + /* renamed from: f */ + public static Class cachedInGameMenuOverlayClass; + + /* renamed from: g */ + public static Class cachedPlayerInputControllerClass; + + /* renamed from: h */ + public static Class cachedBotAiControllerClass; + + /* renamed from: i */ + public static Class cachedGameplayKeyHandlerClass; + + @Override // p000.PlatformServices + /* renamed from: b */ + public final boolean getBoolean141() { + return false; + } + + @Override // p000.PlatformServices + /* renamed from: c */ + public final boolean getBoolean142() { + return true; + } + + @Override // p000.PlatformServices + /* renamed from: d */ + public final boolean getBoolean143() { + return false; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: e */ + public final Class getGameplayCanvasClass() throws ClassNotFoundException { + Class cls = cachedGameplayCanvasClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.GameplayCanvas"); + cachedGameplayCanvasClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: f */ + public final Class getGameModeClass() throws ClassNotFoundException { + Class cls = cachedGameModeClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.RoundBasedGameMode"); + cachedGameModeClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: g */ + public final Class getMainMenuCanvasClass() throws ClassNotFoundException { + Class cls = cachedMainMenuCanvasClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.MainMenuCanvas"); + cachedMainMenuCanvasClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: h */ + public final Class getHudRendererClass() throws ClassNotFoundException { + Class cls = cachedHudRendererClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.HudRenderer"); + cachedHudRendererClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: i */ + public final Class getInGameMenuOverlayClass() throws ClassNotFoundException { + Class cls = cachedInGameMenuOverlayClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.InGameMenuOverlay"); + cachedInGameMenuOverlayClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: j */ + public final Class getPlayerInputControllerClass() throws ClassNotFoundException { + Class cls = cachedPlayerInputControllerClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.PlayerInputController"); + cachedPlayerInputControllerClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: k */ + public final Class getBotAiControllerClass() throws ClassNotFoundException { + Class cls = cachedBotAiControllerClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.BotAIController"); + cachedBotAiControllerClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v2, types: [java.lang.Throwable] */ + @Override // p000.PlatformServices + /* renamed from: l */ + public final Class getGameplayKeyHandlerClass() throws ClassNotFoundException { + Class cls = cachedGameplayKeyHandlerClass; + if (cls != null) { + return cls; + } + try { + cls = Class.forName("p000.GameplayKeyHandler"); + cachedGameplayKeyHandlerClass = cls; + return cls; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls.getMessage()); + } + } + + @Override // p000.PlatformServices + /* renamed from: o */ + public final boolean getBoolean152() { + return false; + } + + @Override // p000.PlatformServices + /* renamed from: p */ + public final boolean getBoolean153() { + return true; + } + + @Override // p000.PlatformServices + /* renamed from: m */ + public final int getPreRoundSeconds() { + return 2; + } + + @Override // p000.PlatformServices + /* renamed from: n */ + public final int getRoundEndSeconds() { + return 3; + } + + @Override // p000.PlatformServices + /* renamed from: q */ + public final void loadMainMenuResources() { + MainMenuCanvas.loadImages70(); + } + + @Override // p000.PlatformServices + /* renamed from: r */ + public final void loadHudResources() { + HudRenderer.loadImages312(); + } + + @Override // p000.PlatformServices + /* renamed from: s */ + public final void loadInGameMenuResources() { + InGameMenuOverlay.loadImages22(); + } + + @Override // p000.PlatformServices + /* renamed from: t */ + public final void unloadMainMenuResources() { + MainMenuCanvas.execute71(); + } + + @Override // p000.PlatformServices + /* renamed from: u */ + public final void unloadHudResources() { + HudRenderer.execute313(); + } + + @Override // p000.PlatformServices + /* renamed from: v */ + public final void unloadInGameMenuResources() { + InGameMenuOverlay.execute36(); + } + + @Override // p000.PlatformServices + /* renamed from: w */ + public final void registerBuiltInMaps() { + MapInfo c0009ai = new MapInfo(); + c0009ai.displayName = "Military base"; + c0009ai.resourcePath = "/res/map/military/military.m3g"; + c0009ai.hasRoundTimer = true; + c0009ai.spawnPoints = new float[]{-84.0f, 3.2f, -63.0f, -34.0f, 0.05f, 81.0f, 35.0f, 0.05f, 106.0f, 108.0f, 0.05f, -94.0f}; + c0009ai.collisionObjectIds = new int[]{239, 240, 241, 243, 244, 246, 247, 248, 249, 250, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266}; + MapManager.getInstance().addMap(c0009ai); + MapInfo c0009ai2 = new MapInfo(); + c0009ai2.displayName = "Command"; + c0009ai2.resourcePath = "/res/map/command/command.m3g"; + c0009ai2.hasRoundTimer = true; + c0009ai2.spawnPoints = new float[]{25.3f, 3.2f, 74.66f, -87.7f, 0.05f, 47.9f, -81.3f, 0.05f, -18.6f, 63.1f, 0.05f, -87.8f}; + c0009ai2.collisionObjectIds = new int[]{296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 331, 332, 333, 334}; + MapManager.getInstance().addMap(c0009ai2); + MapInfo c0009ai3 = new MapInfo(); + c0009ai3.displayName = "Street"; + c0009ai3.resourcePath = "/res/map/street/street.m3g"; + c0009ai3.hasRoundTimer = true; + c0009ai3.spawnPoints = new float[]{26.1f, 3.2f, -12.1f, 74.8f, 0.05f, -120.0f, -59.5f, 0.05f, -121.8f, 90.3f, 0.05f, 111.0f}; + c0009ai3.collisionObjectIds = new int[]{264, 265, 266, 267, 269, 270, 272, 273, 274, 275, 276, 278, 279, 280, 281, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298}; + MapManager.getInstance().addMap(c0009ai3); + MapInfo c0009ai4 = new MapInfo(); + c0009ai4.displayName = "Depository"; + c0009ai4.resourcePath = "/res/map/depository/depository.m3g"; + c0009ai4.hasRoundTimer = true; + c0009ai4.spawnPoints = new float[]{-116.7f, 3.2f, -112.4f, -42.7f, 0.05f, 69.0f, 98.0f, 0.05f, 128.9f, 10.8f, 0.05f, 49.6f}; + c0009ai4.collisionObjectIds = new int[]{213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241}; + MapManager.getInstance().addMap(c0009ai4); + MapInfo c0009ai5 = new MapInfo(); + c0009ai5.displayName = "Fortress"; + c0009ai5.resourcePath = "/res/map/fortress/fortress.m3g"; + c0009ai5.hasRoundTimer = true; + c0009ai5.spawnPoints = new float[]{-2.3f, 3.2f, -8.3f, 1.5f, 0.05f, -96.0f, -5.4f, 0.05f, 102.3f, 90.0f, 0.05f, 50.20508f}; + c0009ai5.collisionObjectIds = new int[]{314, 315, 316, 317, 318, 319, 320, 321, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359}; + MapManager.getInstance().addMap(c0009ai5); + MapInfo c0009ai6 = new MapInfo(); + c0009ai6.displayName = "Construction"; + c0009ai6.resourcePath = "/res/map/construction/construction.m3g"; + c0009ai6.hasRoundTimer = true; + c0009ai6.spawnPoints = new float[]{-51.9f, 3.2f, 123.8f, -13.59f, 0.05f, -101.9f, -104.8f, 0.05f, -127.3f, 101.2f, 0.05f, 119.4f}; + c0009ai6.collisionObjectIds = new int[]{274, 275, 277, 278, 279, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 295, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 309, 310, 312}; + MapManager.getInstance().addMap(c0009ai6); + } + + @Override // p000.PlatformServices + /* renamed from: a */ + public final void loadWeaponDefinitions(int i) { + if (i == 0) { + WeaponInfo c0042k = new WeaponInfo(); + c0042k.name = "MP5"; + c0042k.clipSize = 30; + c0042k.defaultAmmo = c0042k.clipSize * 1; + c0042k.cost = 1500; + c0042k.weightLabel = "3.42KG"; + c0042k.weaponCode = 10; + c0042k.damage = 20; + c0042k.recoilPattern = new int[2][1][4]; + c0042k.recoilPattern[0][0][0] = 0; + c0042k.recoilPattern[0][0][1] = 0; + c0042k.recoilPattern[0][0][2] = 87; + c0042k.recoilPattern[0][0][3] = 68; + c0042k.recoilPattern[1][0][0] = 0; + c0042k.recoilPattern[1][0][1] = 0; + c0042k.recoilPattern[1][0][2] = 64; + c0042k.recoilPattern[1][0][3] = 50; + c0042k.crosshairPattern = new int[2][4]; + c0042k.crosshairPattern[0][0] = 0; + c0042k.crosshairPattern[0][1] = 0; + c0042k.crosshairPattern[0][2] = 71; + c0042k.crosshairPattern[0][3] = 24; + c0042k.crosshairPattern[1][0] = 0; + c0042k.crosshairPattern[1][1] = 0; + c0042k.crosshairPattern[1][2] = 53; + c0042k.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k); + WeaponInfo c0042k2 = new WeaponInfo(); + c0042k2.name = "M4A1"; + c0042k2.clipSize = 30; + c0042k2.defaultAmmo = c0042k2.clipSize * 1; + c0042k2.cost = 3000; + c0042k2.weightLabel = "3.22KG"; + c0042k2.weaponCode = 10; + c0042k2.damage = 30; + c0042k2.recoilPattern = new int[2][1][4]; + c0042k2.recoilPattern[0][0][0] = 0; + c0042k2.recoilPattern[0][0][1] = 68; + c0042k2.recoilPattern[0][0][2] = 87; + c0042k2.recoilPattern[0][0][3] = 68; + c0042k2.recoilPattern[1][0][0] = 0; + c0042k2.recoilPattern[1][0][1] = 50; + c0042k2.recoilPattern[1][0][2] = 64; + c0042k2.recoilPattern[1][0][3] = 51; + c0042k2.crosshairPattern = new int[2][4]; + c0042k2.crosshairPattern[0][0] = 0; + c0042k2.crosshairPattern[0][1] = 24; + c0042k2.crosshairPattern[0][2] = 80; + c0042k2.crosshairPattern[0][3] = 24; + c0042k2.crosshairPattern[1][0] = 0; + c0042k2.crosshairPattern[1][1] = 18; + c0042k2.crosshairPattern[1][2] = 58; + c0042k2.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k2); + WeaponInfo c0042k3 = new WeaponInfo(); + c0042k3.name = "bullpup"; + c0042k3.clipSize = 30; + c0042k3.defaultAmmo = c0042k3.clipSize * 1; + c0042k3.cost = 3500; + c0042k3.weightLabel = "4.09KG"; + c0042k3.weaponCode = 12; + c0042k3.damage = 30; + c0042k3.recoilPattern = new int[2][1][4]; + c0042k3.recoilPattern[0][0][0] = 0; + c0042k3.recoilPattern[0][0][1] = 136; + c0042k3.recoilPattern[0][0][2] = 87; + c0042k3.recoilPattern[0][0][3] = 68; + c0042k3.recoilPattern[1][0][0] = 0; + c0042k3.recoilPattern[1][0][1] = 101; + c0042k3.recoilPattern[1][0][2] = 64; + c0042k3.recoilPattern[1][0][3] = 50; + c0042k3.crosshairPattern = new int[2][4]; + c0042k3.crosshairPattern[0][0] = 0; + c0042k3.crosshairPattern[0][1] = 48; + c0042k3.crosshairPattern[0][2] = 95; + c0042k3.crosshairPattern[0][3] = 24; + c0042k3.crosshairPattern[1][0] = 0; + c0042k3.crosshairPattern[1][1] = 36; + c0042k3.crosshairPattern[1][2] = 69; + c0042k3.crosshairPattern[1][3] = 19; + WeaponLoadout.registerWeapon(c0042k3); + WeaponInfo c0042k4 = new WeaponInfo(); + c0042k4.name = "AWP"; + c0042k4.clipSize = 10; + c0042k4.defaultAmmo = c0042k4.clipSize * 1; + c0042k4.cost = 5000; + c0042k4.weightLabel = "6KG"; + c0042k4.weaponCode = 11; + c0042k4.damage = 100; + c0042k4.recoilPattern = new int[2][1][4]; + c0042k4.recoilPattern[0][0][0] = 0; + c0042k4.recoilPattern[0][0][1] = 204; + c0042k4.recoilPattern[0][0][2] = 87; + c0042k4.recoilPattern[0][0][3] = 68; + c0042k4.recoilPattern[1][0][0] = 0; + c0042k4.recoilPattern[1][0][1] = 151; + c0042k4.recoilPattern[1][0][2] = 64; + c0042k4.recoilPattern[1][0][3] = 51; + c0042k4.crosshairPattern = new int[2][4]; + c0042k4.crosshairPattern[0][0] = 0; + c0042k4.crosshairPattern[0][1] = 72; + c0042k4.crosshairPattern[0][2] = 119; + c0042k4.crosshairPattern[0][3] = 24; + c0042k4.crosshairPattern[1][0] = 0; + c0042k4.crosshairPattern[1][1] = 55; + c0042k4.crosshairPattern[1][2] = 75; + c0042k4.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k4); + WeaponInfo c0042k5 = new WeaponInfo(); + c0042k5.name = "USP"; + c0042k5.clipSize = 12; + c0042k5.defaultAmmo = c0042k5.clipSize * 5; + c0042k5.cost = 500; + c0042k5.weightLabel = "1KG"; + c0042k5.weaponCode = 20; + c0042k5.damage = 15; + c0042k5.recoilPattern = new int[2][1][4]; + c0042k5.recoilPattern[0][0][0] = 114; + c0042k5.recoilPattern[0][0][1] = 0; + c0042k5.recoilPattern[0][0][2] = 52; + c0042k5.recoilPattern[0][0][3] = 68; + c0042k5.recoilPattern[1][0][0] = 83; + c0042k5.recoilPattern[1][0][1] = 0; + c0042k5.recoilPattern[1][0][2] = 38; + c0042k5.recoilPattern[1][0][3] = 50; + c0042k5.crosshairPattern = new int[2][4]; + c0042k5.crosshairPattern[0][0] = 81; + c0042k5.crosshairPattern[0][1] = 24; + c0042k5.crosshairPattern[0][2] = 39; + c0042k5.crosshairPattern[0][3] = 24; + c0042k5.crosshairPattern[1][0] = 58; + c0042k5.crosshairPattern[1][1] = 18; + c0042k5.crosshairPattern[1][2] = 29; + c0042k5.crosshairPattern[1][3] = 19; + WeaponLoadout.registerWeapon(c0042k5); + WeaponInfo c0042k6 = new WeaponInfo(); + c0042k6.name = "DE"; + c0042k6.clipSize = 7; + c0042k6.defaultAmmo = c0042k6.clipSize * 5; + c0042k6.cost = 650; + c0042k6.weightLabel = "1.8KG"; + c0042k6.weaponCode = 20; + c0042k6.damage = 20; + c0042k6.recoilPattern = new int[2][1][4]; + c0042k6.recoilPattern[0][0][0] = 116; + c0042k6.recoilPattern[0][0][1] = 68; + c0042k6.recoilPattern[0][0][2] = 50; + c0042k6.recoilPattern[0][0][3] = 68; + c0042k6.recoilPattern[1][0][0] = 84; + c0042k6.recoilPattern[1][0][1] = 50; + c0042k6.recoilPattern[1][0][2] = 37; + c0042k6.recoilPattern[1][0][3] = 51; + c0042k6.crosshairPattern = new int[2][4]; + c0042k6.crosshairPattern[0][0] = 73; + c0042k6.crosshairPattern[0][1] = 0; + c0042k6.crosshairPattern[0][2] = 47; + c0042k6.crosshairPattern[0][3] = 24; + c0042k6.crosshairPattern[1][0] = 52; + c0042k6.crosshairPattern[1][1] = 0; + c0042k6.crosshairPattern[1][2] = 35; + c0042k6.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k6); + WeaponInfo c0042k7 = new WeaponInfo(); + c0042k7.name = "57"; + c0042k7.clipSize = 20; + c0042k7.defaultAmmo = c0042k7.clipSize * 5; + c0042k7.cost = 750; + c0042k7.weightLabel = "0.618KG"; + c0042k7.weaponCode = 20; + c0042k7.damage = 20; + c0042k7.recoilPattern = new int[2][1][4]; + c0042k7.recoilPattern[0][0][0] = 120; + c0042k7.recoilPattern[0][0][1] = 136; + c0042k7.recoilPattern[0][0][2] = 46; + c0042k7.recoilPattern[0][0][3] = 68; + c0042k7.recoilPattern[1][0][0] = 87; + c0042k7.recoilPattern[1][0][1] = 101; + c0042k7.recoilPattern[1][0][2] = 34; + c0042k7.recoilPattern[1][0][3] = 50; + c0042k7.crosshairPattern = new int[2][4]; + c0042k7.crosshairPattern[0][0] = 0; + c0042k7.crosshairPattern[0][1] = 145; + c0042k7.crosshairPattern[0][2] = 40; + c0042k7.crosshairPattern[0][3] = 24; + c0042k7.crosshairPattern[1][0] = 0; + c0042k7.crosshairPattern[1][1] = 111; + c0042k7.crosshairPattern[1][2] = 29; + c0042k7.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k7); + WeaponInfo c0042k8 = new WeaponInfo(); + c0042k8.name = "Knife"; + c0042k8.clipSize = 1; + c0042k8.defaultAmmo = c0042k8.clipSize; + c0042k8.cost = 0; + c0042k8.weaponCode = 30; + c0042k8.damage = 20; + c0042k8.recoilPattern = new int[2][5][4]; + c0042k8.recoilPattern[0][0][0] = 0; + c0042k8.recoilPattern[0][0][1] = 272; + c0042k8.recoilPattern[0][0][2] = 70; + c0042k8.recoilPattern[0][0][3] = 100; + c0042k8.recoilPattern[0][1][0] = 0; + c0042k8.recoilPattern[0][1][1] = 392; + c0042k8.recoilPattern[0][1][2] = 166; + c0042k8.recoilPattern[0][1][3] = 46; + c0042k8.recoilPattern[0][2][0] = 0; + c0042k8.recoilPattern[0][2][1] = 438; + c0042k8.recoilPattern[0][2][2] = 166; + c0042k8.recoilPattern[0][2][3] = 57; + c0042k8.recoilPattern[0][3][0] = 70; + c0042k8.recoilPattern[0][3][1] = 310; + c0042k8.recoilPattern[0][3][2] = 28; + c0042k8.recoilPattern[0][3][3] = 62; + c0042k8.recoilPattern[0][4][0] = 100; + c0042k8.recoilPattern[0][4][1] = 272; + c0042k8.recoilPattern[0][4][2] = 66; + c0042k8.recoilPattern[0][4][3] = 120; + c0042k8.recoilPattern[1][0][0] = 0; + c0042k8.recoilPattern[1][0][1] = 202; + c0042k8.recoilPattern[1][0][2] = 52; + c0042k8.recoilPattern[1][0][3] = 74; + c0042k8.recoilPattern[1][1][0] = 0; + c0042k8.recoilPattern[1][1][1] = 290; + c0042k8.recoilPattern[1][1][2] = 107; + c0042k8.recoilPattern[1][1][3] = 35; + c0042k8.recoilPattern[1][2][0] = 0; + c0042k8.recoilPattern[1][2][1] = 325; + c0042k8.recoilPattern[1][2][2] = 90; + c0042k8.recoilPattern[1][2][3] = 42; + c0042k8.recoilPattern[1][3][0] = 50; + c0042k8.recoilPattern[1][3][1] = 230; + c0042k8.recoilPattern[1][3][2] = 22; + c0042k8.recoilPattern[1][3][3] = 46; + c0042k8.recoilPattern[1][4][0] = 72; + c0042k8.recoilPattern[1][4][1] = 202; + c0042k8.recoilPattern[1][4][2] = 49; + c0042k8.recoilPattern[1][4][3] = 88; + c0042k8.crosshairPattern = new int[2][4]; + c0042k8.crosshairPattern[0][0] = 40; + c0042k8.crosshairPattern[0][1] = 148; + c0042k8.crosshairPattern[0][2] = 80; + c0042k8.crosshairPattern[0][3] = 14; + c0042k8.crosshairPattern[1][0] = 29; + c0042k8.crosshairPattern[1][1] = 113; + c0042k8.crosshairPattern[1][2] = 58; + c0042k8.crosshairPattern[1][3] = 11; + WeaponLoadout.registerWeapon(c0042k8); + WeaponInfo c0042k9 = new WeaponInfo(); + c0042k9.name = "Grenade"; + c0042k9.clipSize = 1; + c0042k9.defaultAmmo = c0042k9.clipSize; + c0042k9.cost = 300; + c0042k9.weaponCode = 40; + c0042k9.damage = 80; + c0042k9.recoilPattern = new int[2][1][4]; + c0042k9.recoilPattern[0][0][0] = 88; + c0042k9.recoilPattern[0][0][1] = 204; + c0042k9.recoilPattern[0][0][2] = 78; + c0042k9.recoilPattern[0][0][3] = 68; + c0042k9.recoilPattern[1][0][0] = 64; + c0042k9.recoilPattern[1][0][1] = 151; + c0042k9.recoilPattern[1][0][2] = 57; + c0042k9.recoilPattern[1][0][3] = 51; + c0042k9.crosshairPattern = new int[2][4]; + c0042k9.crosshairPattern[0][0] = 0; + c0042k9.crosshairPattern[0][1] = 96; + c0042k9.crosshairPattern[0][2] = 46; + c0042k9.crosshairPattern[0][3] = 40; + c0042k9.crosshairPattern[1][0] = 0; + c0042k9.crosshairPattern[1][1] = 73; + c0042k9.crosshairPattern[1][2] = 34; + c0042k9.crosshairPattern[1][3] = 29; + WeaponLoadout.registerWeapon(c0042k9); + WeaponInfo c0042k10 = new WeaponInfo(); + c0042k10.name = "Kevlar"; + c0042k10.clipSize = 1; + c0042k10.defaultAmmo = c0042k10.clipSize; + c0042k10.cost = 650; + c0042k10.weaponCode = 60; + c0042k10.crosshairPattern = new int[2][4]; + c0042k10.crosshairPattern[0][0] = 78; + c0042k10.crosshairPattern[0][1] = 96; + c0042k10.crosshairPattern[0][2] = 42; + c0042k10.crosshairPattern[0][3] = 52; + c0042k10.crosshairPattern[1][0] = 58; + c0042k10.crosshairPattern[1][1] = 73; + c0042k10.crosshairPattern[1][2] = 29; + c0042k10.crosshairPattern[1][3] = 40; + WeaponLoadout.registerWeapon(c0042k10); + WeaponInfo c0042k11 = new WeaponInfo(); + c0042k11.name = "1 ammo"; + c0042k11.cost = 60; + c0042k11.weaponCode = 50; + c0042k11.crosshairPattern = new int[2][4]; + c0042k11.crosshairPattern[0][0] = 0; + c0042k11.crosshairPattern[0][1] = 136; + c0042k11.crosshairPattern[0][2] = 49; + c0042k11.crosshairPattern[0][3] = 9; + c0042k11.crosshairPattern[1][0] = 0; + c0042k11.crosshairPattern[1][1] = 102; + c0042k11.crosshairPattern[1][2] = 36; + c0042k11.crosshairPattern[1][3] = 8; + WeaponLoadout.registerWeapon(c0042k11); + WeaponInfo c0042k12 = new WeaponInfo(); + c0042k12.name = "2 ammo"; + c0042k12.cost = 25; + c0042k12.weaponCode = 51; + c0042k12.crosshairPattern = new int[2][4]; + c0042k12.crosshairPattern[0][0] = 49; + c0042k12.crosshairPattern[0][1] = 136; + c0042k12.crosshairPattern[0][2] = 29; + c0042k12.crosshairPattern[0][3] = 11; + c0042k12.crosshairPattern[1][0] = 36; + c0042k12.crosshairPattern[1][1] = 102; + c0042k12.crosshairPattern[1][2] = 22; + c0042k12.crosshairPattern[1][3] = 9; + WeaponLoadout.registerWeapon(c0042k12); + return; + } + WeaponInfo c0042k13 = new WeaponInfo(); + c0042k13.name = "Galil"; + c0042k13.clipSize = 35; + c0042k13.defaultAmmo = c0042k13.clipSize * 1; + c0042k13.cost = 2000; + c0042k13.weightLabel = "4.35KG"; + c0042k13.weaponCode = 10; + c0042k13.damage = 20; + c0042k13.recoilPattern = new int[2][1][4]; + c0042k13.recoilPattern[0][0][0] = 0; + c0042k13.recoilPattern[0][0][1] = 0; + c0042k13.recoilPattern[0][0][2] = 87; + c0042k13.recoilPattern[0][0][3] = 68; + c0042k13.recoilPattern[1][0][0] = 0; + c0042k13.recoilPattern[1][0][1] = 0; + c0042k13.recoilPattern[1][0][2] = 64; + c0042k13.recoilPattern[1][0][3] = 50; + c0042k13.crosshairPattern = new int[2][4]; + c0042k13.crosshairPattern[0][0] = 0; + c0042k13.crosshairPattern[0][1] = 0; + c0042k13.crosshairPattern[0][2] = 71; + c0042k13.crosshairPattern[0][3] = 24; + c0042k13.crosshairPattern[1][0] = 0; + c0042k13.crosshairPattern[1][1] = 0; + c0042k13.crosshairPattern[1][2] = 53; + c0042k13.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k13); + WeaponInfo c0042k14 = new WeaponInfo(); + c0042k14.name = "ak47"; + c0042k14.clipSize = 30; + c0042k14.defaultAmmo = c0042k14.clipSize * 1; + c0042k14.cost = 2500; + c0042k14.weightLabel = "4.79KG"; + c0042k14.weaponCode = 10; + c0042k14.damage = 30; + c0042k14.recoilPattern = new int[2][1][4]; + c0042k14.recoilPattern[0][0][0] = 0; + c0042k14.recoilPattern[0][0][1] = 68; + c0042k14.recoilPattern[0][0][2] = 87; + c0042k14.recoilPattern[0][0][3] = 68; + c0042k14.recoilPattern[1][0][0] = 0; + c0042k14.recoilPattern[1][0][1] = 50; + c0042k14.recoilPattern[1][0][2] = 64; + c0042k14.recoilPattern[1][0][3] = 51; + c0042k14.crosshairPattern = new int[2][4]; + c0042k14.crosshairPattern[0][0] = 0; + c0042k14.crosshairPattern[0][1] = 24; + c0042k14.crosshairPattern[0][2] = 80; + c0042k14.crosshairPattern[0][3] = 24; + c0042k14.crosshairPattern[1][0] = 0; + c0042k14.crosshairPattern[1][1] = 18; + c0042k14.crosshairPattern[1][2] = 58; + c0042k14.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k14); + WeaponInfo c0042k15 = new WeaponInfo(); + c0042k15.name = "Krieg 552"; + c0042k15.clipSize = 30; + c0042k15.defaultAmmo = c0042k15.clipSize * 1; + c0042k15.cost = 3500; + c0042k15.weightLabel = "3.1KG"; + c0042k15.weaponCode = 12; + c0042k15.damage = 30; + c0042k15.recoilPattern = new int[2][1][4]; + c0042k15.recoilPattern[0][0][0] = 0; + c0042k15.recoilPattern[0][0][1] = 136; + c0042k15.recoilPattern[0][0][2] = 87; + c0042k15.recoilPattern[0][0][3] = 68; + c0042k15.recoilPattern[1][0][0] = 0; + c0042k15.recoilPattern[1][0][1] = 101; + c0042k15.recoilPattern[1][0][2] = 64; + c0042k15.recoilPattern[1][0][3] = 50; + c0042k15.crosshairPattern = new int[2][4]; + c0042k15.crosshairPattern[0][0] = 0; + c0042k15.crosshairPattern[0][1] = 48; + c0042k15.crosshairPattern[0][2] = 95; + c0042k15.crosshairPattern[0][3] = 24; + c0042k15.crosshairPattern[1][0] = 0; + c0042k15.crosshairPattern[1][1] = 36; + c0042k15.crosshairPattern[1][2] = 69; + c0042k15.crosshairPattern[1][3] = 19; + WeaponLoadout.registerWeapon(c0042k15); + WeaponInfo c0042k16 = new WeaponInfo(); + c0042k16.name = "AWP"; + c0042k16.clipSize = 10; + c0042k16.defaultAmmo = c0042k16.clipSize * 1; + c0042k16.cost = 5000; + c0042k16.weightLabel = "6KG"; + c0042k16.weaponCode = 11; + c0042k16.damage = 100; + c0042k16.recoilPattern = new int[2][1][4]; + c0042k16.recoilPattern[0][0][0] = 0; + c0042k16.recoilPattern[0][0][1] = 204; + c0042k16.recoilPattern[0][0][2] = 87; + c0042k16.recoilPattern[0][0][3] = 68; + c0042k16.recoilPattern[1][0][0] = 0; + c0042k16.recoilPattern[1][0][1] = 151; + c0042k16.recoilPattern[1][0][2] = 64; + c0042k16.recoilPattern[1][0][3] = 51; + c0042k16.crosshairPattern = new int[2][4]; + c0042k16.crosshairPattern[0][0] = 0; + c0042k16.crosshairPattern[0][1] = 72; + c0042k16.crosshairPattern[0][2] = 119; + c0042k16.crosshairPattern[0][3] = 24; + c0042k16.crosshairPattern[1][0] = 0; + c0042k16.crosshairPattern[1][1] = 55; + c0042k16.crosshairPattern[1][2] = 75; + c0042k16.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k16); + WeaponInfo c0042k17 = new WeaponInfo(); + c0042k17.name = "clock 18"; + c0042k17.clipSize = 20; + c0042k17.defaultAmmo = c0042k17.clipSize * 3; + c0042k17.cost = 400; + c0042k17.weightLabel = "0.9KG"; + c0042k17.weaponCode = 20; + c0042k17.damage = 15; + c0042k17.recoilPattern = new int[2][1][4]; + c0042k17.recoilPattern[0][0][0] = 114; + c0042k17.recoilPattern[0][0][1] = 0; + c0042k17.recoilPattern[0][0][2] = 52; + c0042k17.recoilPattern[0][0][3] = 68; + c0042k17.recoilPattern[1][0][0] = 83; + c0042k17.recoilPattern[1][0][1] = 0; + c0042k17.recoilPattern[1][0][2] = 38; + c0042k17.recoilPattern[1][0][3] = 50; + c0042k17.crosshairPattern = new int[2][4]; + c0042k17.crosshairPattern[0][0] = 81; + c0042k17.crosshairPattern[0][1] = 24; + c0042k17.crosshairPattern[0][2] = 39; + c0042k17.crosshairPattern[0][3] = 24; + c0042k17.crosshairPattern[1][0] = 58; + c0042k17.crosshairPattern[1][1] = 18; + c0042k17.crosshairPattern[1][2] = 29; + c0042k17.crosshairPattern[1][3] = 19; + WeaponLoadout.registerWeapon(c0042k17); + WeaponInfo c0042k18 = new WeaponInfo(); + c0042k18.name = "DE"; + c0042k18.clipSize = 7; + c0042k18.defaultAmmo = c0042k18.clipSize * 5; + c0042k18.cost = 650; + c0042k18.weightLabel = "1.8KG"; + c0042k18.weaponCode = 20; + c0042k18.damage = 20; + c0042k18.recoilPattern = new int[2][1][4]; + c0042k18.recoilPattern[0][0][0] = 116; + c0042k18.recoilPattern[0][0][1] = 68; + c0042k18.recoilPattern[0][0][2] = 50; + c0042k18.recoilPattern[0][0][3] = 68; + c0042k18.recoilPattern[1][0][0] = 84; + c0042k18.recoilPattern[1][0][1] = 50; + c0042k18.recoilPattern[1][0][2] = 37; + c0042k18.recoilPattern[1][0][3] = 51; + c0042k18.crosshairPattern = new int[2][4]; + c0042k18.crosshairPattern[0][0] = 73; + c0042k18.crosshairPattern[0][1] = 0; + c0042k18.crosshairPattern[0][2] = 47; + c0042k18.crosshairPattern[0][3] = 24; + c0042k18.crosshairPattern[1][0] = 52; + c0042k18.crosshairPattern[1][1] = 0; + c0042k18.crosshairPattern[1][2] = 35; + c0042k18.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k18); + WeaponInfo c0042k19 = new WeaponInfo(); + c0042k19.name = "57"; + c0042k19.clipSize = 20; + c0042k19.defaultAmmo = c0042k19.clipSize * 5; + c0042k19.cost = 750; + c0042k19.weightLabel = "0.618KG"; + c0042k19.weaponCode = 20; + c0042k19.damage = 20; + c0042k19.recoilPattern = new int[2][1][4]; + c0042k19.recoilPattern[0][0][0] = 120; + c0042k19.recoilPattern[0][0][1] = 136; + c0042k19.recoilPattern[0][0][2] = 46; + c0042k19.recoilPattern[0][0][3] = 68; + c0042k19.recoilPattern[1][0][0] = 87; + c0042k19.recoilPattern[1][0][1] = 101; + c0042k19.recoilPattern[1][0][2] = 34; + c0042k19.recoilPattern[1][0][3] = 50; + c0042k19.crosshairPattern = new int[2][4]; + c0042k19.crosshairPattern[0][0] = 0; + c0042k19.crosshairPattern[0][1] = 145; + c0042k19.crosshairPattern[0][2] = 40; + c0042k19.crosshairPattern[0][3] = 24; + c0042k19.crosshairPattern[1][0] = 0; + c0042k19.crosshairPattern[1][1] = 111; + c0042k19.crosshairPattern[1][2] = 29; + c0042k19.crosshairPattern[1][3] = 18; + WeaponLoadout.registerWeapon(c0042k19); + WeaponInfo c0042k20 = new WeaponInfo(); + c0042k20.name = "Knife"; + c0042k20.clipSize = 1; + c0042k20.defaultAmmo = c0042k20.clipSize; + c0042k20.cost = 0; + c0042k20.weaponCode = 30; + c0042k20.damage = 20; + c0042k20.recoilPattern = new int[2][5][4]; + c0042k20.recoilPattern[0][0][0] = 0; + c0042k20.recoilPattern[0][0][1] = 272; + c0042k20.recoilPattern[0][0][2] = 70; + c0042k20.recoilPattern[0][0][3] = 100; + c0042k20.recoilPattern[0][1][0] = 0; + c0042k20.recoilPattern[0][1][1] = 392; + c0042k20.recoilPattern[0][1][2] = 166; + c0042k20.recoilPattern[0][1][3] = 46; + c0042k20.recoilPattern[0][2][0] = 0; + c0042k20.recoilPattern[0][2][1] = 438; + c0042k20.recoilPattern[0][2][2] = 166; + c0042k20.recoilPattern[0][2][3] = 57; + c0042k20.recoilPattern[0][3][0] = 70; + c0042k20.recoilPattern[0][3][1] = 310; + c0042k20.recoilPattern[0][3][2] = 28; + c0042k20.recoilPattern[0][3][3] = 62; + c0042k20.recoilPattern[0][4][0] = 100; + c0042k20.recoilPattern[0][4][1] = 272; + c0042k20.recoilPattern[0][4][2] = 66; + c0042k20.recoilPattern[0][4][3] = 120; + c0042k20.recoilPattern[1][0][0] = 0; + c0042k20.recoilPattern[1][0][1] = 202; + c0042k20.recoilPattern[1][0][2] = 52; + c0042k20.recoilPattern[1][0][3] = 74; + c0042k20.recoilPattern[1][1][0] = 0; + c0042k20.recoilPattern[1][1][1] = 290; + c0042k20.recoilPattern[1][1][2] = 107; + c0042k20.recoilPattern[1][1][3] = 35; + c0042k20.recoilPattern[1][2][0] = 0; + c0042k20.recoilPattern[1][2][1] = 325; + c0042k20.recoilPattern[1][2][2] = 90; + c0042k20.recoilPattern[1][2][3] = 42; + c0042k20.recoilPattern[1][3][0] = 50; + c0042k20.recoilPattern[1][3][1] = 230; + c0042k20.recoilPattern[1][3][2] = 22; + c0042k20.recoilPattern[1][3][3] = 46; + c0042k20.recoilPattern[1][4][0] = 72; + c0042k20.recoilPattern[1][4][1] = 202; + c0042k20.recoilPattern[1][4][2] = 49; + c0042k20.recoilPattern[1][4][3] = 88; + c0042k20.crosshairPattern = new int[2][4]; + c0042k20.crosshairPattern[0][0] = 40; + c0042k20.crosshairPattern[0][1] = 148; + c0042k20.crosshairPattern[0][2] = 80; + c0042k20.crosshairPattern[0][3] = 14; + c0042k20.crosshairPattern[1][0] = 29; + c0042k20.crosshairPattern[1][1] = 113; + c0042k20.crosshairPattern[1][2] = 58; + c0042k20.crosshairPattern[1][3] = 11; + WeaponLoadout.registerWeapon(c0042k20); + WeaponInfo c0042k21 = new WeaponInfo(); + c0042k21.name = "Grenade"; + c0042k21.clipSize = 1; + c0042k21.defaultAmmo = c0042k21.clipSize; + c0042k21.cost = 300; + c0042k21.weaponCode = 40; + c0042k21.damage = 80; + c0042k21.recoilPattern = new int[2][1][4]; + c0042k21.recoilPattern[0][0][0] = 88; + c0042k21.recoilPattern[0][0][1] = 204; + c0042k21.recoilPattern[0][0][2] = 78; + c0042k21.recoilPattern[0][0][3] = 68; + c0042k21.recoilPattern[1][0][0] = 64; + c0042k21.recoilPattern[1][0][1] = 151; + c0042k21.recoilPattern[1][0][2] = 57; + c0042k21.recoilPattern[1][0][3] = 51; + c0042k21.crosshairPattern = new int[2][4]; + c0042k21.crosshairPattern[0][0] = 0; + c0042k21.crosshairPattern[0][1] = 96; + c0042k21.crosshairPattern[0][2] = 46; + c0042k21.crosshairPattern[0][3] = 40; + c0042k21.crosshairPattern[1][0] = 0; + c0042k21.crosshairPattern[1][1] = 73; + c0042k21.crosshairPattern[1][2] = 34; + c0042k21.crosshairPattern[1][3] = 29; + WeaponLoadout.registerWeapon(c0042k21); + WeaponInfo c0042k22 = new WeaponInfo(); + c0042k22.name = "Kevlar"; + c0042k22.clipSize = 1; + c0042k22.defaultAmmo = c0042k22.clipSize; + c0042k22.cost = 650; + c0042k22.weaponCode = 60; + c0042k22.crosshairPattern = new int[2][4]; + c0042k22.crosshairPattern[0][0] = 78; + c0042k22.crosshairPattern[0][1] = 96; + c0042k22.crosshairPattern[0][2] = 42; + c0042k22.crosshairPattern[0][3] = 52; + c0042k22.crosshairPattern[1][0] = 58; + c0042k22.crosshairPattern[1][1] = 73; + c0042k22.crosshairPattern[1][2] = 29; + c0042k22.crosshairPattern[1][3] = 40; + WeaponLoadout.registerWeapon(c0042k22); + WeaponInfo c0042k23 = new WeaponInfo(); + c0042k23.name = "1 ammo"; + c0042k23.cost = 60; + c0042k23.weaponCode = 50; + c0042k23.crosshairPattern = new int[2][4]; + c0042k23.crosshairPattern[0][0] = 0; + c0042k23.crosshairPattern[0][1] = 136; + c0042k23.crosshairPattern[0][2] = 49; + c0042k23.crosshairPattern[0][3] = 9; + c0042k23.crosshairPattern[1][0] = 0; + c0042k23.crosshairPattern[1][1] = 102; + c0042k23.crosshairPattern[1][2] = 36; + c0042k23.crosshairPattern[1][3] = 8; + WeaponLoadout.registerWeapon(c0042k23); + WeaponInfo c0042k24 = new WeaponInfo(); + c0042k24.name = "2 ammo"; + c0042k24.cost = 25; + c0042k24.weaponCode = 51; + c0042k24.crosshairPattern = new int[2][4]; + c0042k24.crosshairPattern[0][0] = 49; + c0042k24.crosshairPattern[0][1] = 136; + c0042k24.crosshairPattern[0][2] = 29; + c0042k24.crosshairPattern[0][3] = 11; + c0042k24.crosshairPattern[1][0] = 36; + c0042k24.crosshairPattern[1][1] = 102; + c0042k24.crosshairPattern[1][2] = 22; + c0042k24.crosshairPattern[1][3] = 9; + WeaponLoadout.registerWeapon(c0042k24); + } + + @Override // p000.PlatformServices + /* renamed from: x */ + public final void initCameras() { + CameraManager.getInstance().execute120("MAIN", new Camera()); + } +} diff --git a/p000/FastAcos.java b/p000/FastAcos.java new file mode 100644 index 0000000..de1a008 --- /dev/null +++ b/p000/FastAcos.java @@ -0,0 +1,20 @@ +package p000; + +/* renamed from: ag */ +/* loaded from: microcounterstrike.jar:ag.class */ +public final class FastAcos { + /* renamed from: a */ + public static double getDouble78(double d) { + if (d > 1.0d) { + d = 1.0d; + } else if (d < -1.0d) { + d = -1.0d; + } + double dAbs = Math.abs(d); + double dSqrt = Math.sqrt(1.0d - dAbs) * (((1.5707288d - (0.212114d * dAbs)) + ((0.074261d * dAbs) * dAbs)) - (((0.0187293d * dAbs) * dAbs) * dAbs)); + if (d < 0.0d) { + dSqrt = 3.141592653589793d - dSqrt; + } + return dSqrt; + } +} diff --git a/p000/GameLoadingThread.java b/p000/GameLoadingThread.java new file mode 100644 index 0000000..14ba115 --- /dev/null +++ b/p000/GameLoadingThread.java @@ -0,0 +1,214 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import java.io.IOException; +import java.util.Hashtable; +import javax.microedition.m3g.World; + +/* renamed from: aj */ +/* loaded from: microcounterstrike.jar:aj.class */ +public final class GameLoadingThread implements Runnable { + + /* renamed from: c */ + private static GameLoadingThread gameLoadingThread69; + + /* renamed from: d */ + private static boolean flag70 = false; + + /* renamed from: a */ + public int value71 = 0; + + /* renamed from: b */ + public int value72 = 0; + + private GameLoadingThread() { + } + + /* renamed from: a */ + public static GameLoadingThread getInstance() { + if (gameLoadingThread69 == null) { + gameLoadingThread69 = new GameLoadingThread(); + } + return gameLoadingThread69; + } + + /* renamed from: b */ + public static void execute94() { + switch (GameSessionLoop.getInstance().sessionType) { + case 0: + SceneRootNode c0000a = new SceneRootNode(); + int i = MainUiCanvasBase.getInstance().value183; + PlayerManager.getInstance().addPlayer(new LocalPlayer(1, "Me", i, 1, c0000a)); + float[] fArr = MapManager.getInstance().getCurrentMapInfo().spawnPoints; + for (int i2 = 1; i2 < fArr.length / 3; i2++) { + PlayerManager.getInstance().addPlayer(new RemotePlayer(i2 + 1, "Bot", 1 - i, 2)); + } + break; + case 1: + PlayerManager.getInstance().addPlayer(new LocalPlayer(1, "Me", 0, 1, new SceneRootNode())); + if (ConnectionManager.getInstance_2() != null) { + PlayerManager.getInstance().addPlayer(new RemotePlayer(2, "BT Player", 1, 3)); + break; + } + break; + case 2: + PlayerManager.getInstance().addPlayer(new LocalPlayer(1, "Me", 1, 1, new SceneRootNode())); + PlayerManager.getInstance().addPlayer(new RemotePlayer(2, "BT Player", 0, 3)); + break; + } + } + + /* renamed from: c */ + public static void showScreen95() { + GameAppMidlet.getInstance().display.setCurrent(MainUiCanvasBase.getInstance()); + MainUiCanvasBase.getInstance().execute37(); + new Thread(gameLoadingThread69).start(); + } + + @Override // java.lang.Runnable + public final void run() throws IOException { + try { + MainUiCanvasBase.getInstance().value181 = 9; + this.value72++; + this.value71 = 1; + MainUiCanvasBase.getInstance().execute37(); + CameraManager.getInstance().execute118(); + this.value72++; + World worldM2b = MapManager.getInstance().loadCurrentMap(); + this.value72++; + this.value71 = 20; + MainUiCanvasBase.getInstance().execute37(); + this.value72++; + if (!flag70 && PlatformServices.getInstance().getBoolean141()) { + BulletHoleManager.execute303(worldM2b); + } + this.value72++; + this.value71 = 25; + MainUiCanvasBase.getInstance().execute37(); + if (!flag70) { + GrenadeController.execute72(); + } + this.value72++; + this.value71 = 28; + MainUiCanvasBase.getInstance().execute37(); + if (!flag70) { + ParticleEffectManager.execute291(); + } + this.value72++; + this.value71 = 35; + MainUiCanvasBase.getInstance().execute37(); + this.value71 = 50; + MainUiCanvasBase.getInstance().execute37(); + this.value72++; + if (!flag70) { + MuzzleFlashManager.execute208(); + } + this.value72++; + this.value71 = 60; + MainUiCanvasBase.getInstance().execute37(); + PlayerManager.getInstance().addAllToWorld(worldM2b); + this.value71 = 80; + MainUiCanvasBase.getInstance().execute37(); + this.value72++; + this.value71 = 85; + MainUiCanvasBase.getInstance().execute37(); + HudBase.execute239(); + this.value72++; + this.value71 = 90; + MainUiCanvasBase.getInstance().execute37(); + OverlayMenuBase.execute231(); + this.value72++; + this.value71 = 95; + MainUiCanvasBase.getInstance().execute37(); + System.gc(); + this.value71 = 100; + MainUiCanvasBase.getInstance().execute37(); + this.value72++; + flag70 = true; + int i = GameSessionLoop.getInstance().sessionType; + if (i == 0) { + this.value71 = 0; + execute97(); + return; + } + if (i != 1) { + if (i == 2) { + BluetoothDiscoveryClient.getInstance().bluetoothControlChannel233.sendPacket135(); + this.value71 = 0; + return; + } + return; + } + ConnectionManager c0035dM216a = ConnectionManager.getInstance_2(); + if (c0035dM216a != null) { + try { + c0035dM216a.input169.readInt(); + } catch (IOException unused) { + c0035dM216a.sendPacket223(); + ConnectionManager.execute217(); + } + } + execute96(); + if (ConnectionManager.getInstance_2() != null) { + try { + ConnectionManager.getInstance_2().sendPacket221(); + } catch (IOException unused2) { + } + } + this.value71 = 0; + execute97(); + } catch (Exception e) { + GameAppMidlet.getInstance().display.setCurrent(MainUiCanvasBase.getInstance()); + MainUiCanvasBase.getInstance().showScreen53(new StringBuffer(String.valueOf(this.value72)).append(e.toString()).toString()); + } + } + + /* renamed from: f */ + private static void execute96() { + if (ConnectionManager.getInstance_2() == null || !ConnectionManager.getInstance_2().flag171) { + return; + } + Hashtable hashtable = PlayerManager.getInstance().playersById; + Integer num = new Integer(2); + ((PlayerEntityBase) hashtable.get(num)).removeFromWorld(); + hashtable.remove(num); + } + + /* renamed from: g */ + private static void execute97() { + GameSessionLoop.getInstance().start(); + } + + /* renamed from: d */ + public static void execute98() { + CameraManager.getInstance().execute119(); + MapManager.getInstance().unloadMap(); + if (PlatformServices.getInstance().getBoolean141()) { + BulletHoleManager.getInstance().execute306(); + } + ParticleEffectManager.getInstance().execute297(); + MuzzleFlashManager.getInstance().execute211(); + HudBase.getInstance().execute238(); + OverlayMenuBase.getInstance(); + PlayerManager.getInstance().disposeAll(); + GameRenderCanvas.execute21(); + Runtime.getRuntime().gc(); + } + + /* renamed from: e */ + public static void execute99() { + if (PlatformServices.getInstance().getBoolean141()) { + BulletHoleManager.execute307(); + } + ParticleEffectManager.execute298(); + GrenadeController.execute77(); + WeaponLoadout.clearWeaponCatalog(); + if (MainUiCanvasBase.getInstance().soundEnabled) { + SoundManager.getInstance().execute202(); + } + MuzzleFlashManager.execute212(); + HudBase.execute240(); + OverlayMenuBase.execute232(); + Runtime.getRuntime().gc(); + } +} diff --git a/p000/GameRenderCanvas.java b/p000/GameRenderCanvas.java new file mode 100644 index 0000000..4208680 --- /dev/null +++ b/p000/GameRenderCanvas.java @@ -0,0 +1,149 @@ +package p000; + +import javax.microedition.lcdui.Graphics; +import javax.microedition.lcdui.game.GameCanvas; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.Graphics3D; +import javax.microedition.m3g.Transform; + +/* renamed from: ab */ +/* loaded from: microcounterstrike.jar:ab.class */ +public class GameRenderCanvas extends GameCanvas { + + /* renamed from: b */ + private static GameRenderCanvas gameRenderCanvas7; + + /* renamed from: c */ + private Graphics3D graphics3D8; + + /* renamed from: d */ + private Graphics graphics9; + + /* renamed from: a */ + public boolean flag10; + + public GameRenderCanvas() { + super(false); + this.graphics3D8 = Graphics3D.getInstance(); + this.graphics9 = getGraphics(); + initCanvas13(); + } + + /* renamed from: b */ + public final void initCanvas13() { + if (PlatformServices.getInstance().getBoolean153()) { + setFullScreenMode(true); + } + MapManager.getInstance().setBackgroundCrop(getWidth(), getHeight()); + CameraManager.getInstance().execute122(CameraManager.getInstance().getCamera121("MAIN"), this); + execute20(false); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0 */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v7, types: [ab] */ + /* JADX WARN: Type inference failed for: r0v8 */ + /* renamed from: c */ + public static GameRenderCanvas getInstance() { + ?? r0 = 0; + r0 = 0; + gameRenderCanvas7 = null; + try { + r0 = (GameRenderCanvas) PlatformServices.getInstance().getGameplayCanvasClass().newInstance(); + gameRenderCanvas7 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + return gameRenderCanvas7; + } + + /* renamed from: d */ + public static GameRenderCanvas getInstance_2() { + return gameRenderCanvas7; + } + + /* renamed from: e */ + public final void execute16() { + try { + execute17(); + execute18(); + flushGraphics(); + } catch (Exception e) { + System.out.println(e); + e.printStackTrace(); + } + } + + /* renamed from: h */ + private void execute17() { + Graphics3D graphics3D; + try { + try { + InputStateBase.getInstance().execute125(); + if (GameSessionLoop.getInstance().sessionType == 0) { + AiControllerBase.getInstance().execute114(); + } else if (GameSessionLoop.getInstance().sessionType == 1) { + BluetoothClientSync.getInstance().sendPacket244(); + } else if (GameSessionLoop.getInstance().sessionType == 2) { + BluetoothHostSync.getInstance().sendPacket103(); + } + PlayerManager.getInstance().updateVisibility(); + execute19(); + this.graphics3D8.bindTarget(this.graphics9, true, 6); + graphics3D = this.graphics3D8; + graphics3D.render(MapManager.getInstance().world); + } catch (Exception e) { + graphics3D.printStackTrace(); + } + } finally { + this.graphics3D8.releaseTarget(); + this.graphics3D8.setCamera((Camera) null, (Transform) null); + this.graphics3D8.resetLights(); + } + } + + /* renamed from: f */ + public final void execute18() { + HudBase.getInstance().execute236(this.graphics9, this); + OverlayMenuBase.getInstance().execute23(this.graphics9, this); + } + + /* renamed from: a */ + public void execute19() { + } + + /* renamed from: a */ + public final void execute20(boolean z) { + this.flag10 = z; + float width = getWidth() / getHeight(); + Camera camera = CameraManager.getInstance().camera89; + float f = 60.0f / width; + if (z) { + f /= 2.0f; + } + camera.setPerspective(f, width, 0.1f, 300.0f); + } + + public void keyPressed(int i) { + KeyInputHandlerBase.getInstance().execute127(i, this); + } + + public void keyReleased(int i) { + KeyInputHandlerBase.getInstance().execute128(i, this); + } + + /* renamed from: g */ + public static void execute21() { + gameRenderCanvas7.graphics9 = null; + gameRenderCanvas7.graphics3D8 = null; + gameRenderCanvas7 = null; + } + + public void sizeChanged(int i, int i2) { + this.graphics9 = getGraphics(); + } +} diff --git a/p000/GameSessionLoop.java b/p000/GameSessionLoop.java new file mode 100644 index 0000000..763fd0a --- /dev/null +++ b/p000/GameSessionLoop.java @@ -0,0 +1,131 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import java.util.Timer; + +/* renamed from: an */ +/* loaded from: microcounterstrike.jar:an.class */ +public abstract class GameSessionLoop implements Runnable { + + /* renamed from: e */ + private static GameSessionLoop instance; + + /* renamed from: a */ + public int sessionType; + + /* renamed from: c */ + public CountdownTimerTask countdownTask; + + /* renamed from: b */ + public int sessionState = 5; + + /* renamed from: d */ + public int roundEndTriggered = 0; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [an] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [an] */ + /* renamed from: a */ + public static GameSessionLoop getInstance() { + ?? r0 = instance; + if (r0 == 0) { + try { + r0 = (GameSessionLoop) PlatformServices.getInstance().getGameModeClass().newInstance(); + instance = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return instance; + } + + /* renamed from: b */ + public final void start() { + if (this.sessionState == 4 || this.sessionState == 5) { + Thread thread = new Thread(this); + this.roundEndTriggered = 0; + thread.start(); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v16, types: [int] */ + /* JADX WARN: Type inference failed for: r0v17, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v20, types: [int] */ + @Override // java.lang.Runnable + public void run() { + ?? r0; + GameRenderCanvas c0002abM14c = GameRenderCanvas.getInstance(); + GameAppMidlet.getInstance().display.setCurrent(c0002abM14c); + onSessionStart(); + this.sessionState = 1; + this.countdownTask = new CountdownTimerTask(PlatformServices.getInstance().getPreRoundSeconds()); + Timer timer = new Timer(); + timer.schedule(this.countdownTask, 0L, 1000L); + while (this.sessionState != 4 && (r0 = this.sessionState) != 5) { + try { + c0002abM14c.execute16(); + r0 = this.sessionState; + if (r0 == 1 && this.countdownTask.value11 == 0 && this.sessionType != 2) { + this.sessionState = 2; + this.countdownTask = null; + if (MapManager.getInstance().getCurrentMapInfo().hasRoundTimer) { + this.countdownTask = new CountdownTimerTask(180); + timer.schedule(this.countdownTask, 0L, 1000L); + } + } + if (this.sessionState == 2) { + if ((MapManager.getInstance().getCurrentMapInfo().hasRoundTimer && this.countdownTask.value11 == 0) || this.roundEndTriggered != 0) { + this.sessionState = 3; + onRoundStart(); + if (MapManager.getInstance().getCurrentMapInfo().hasRoundTimer) { + this.countdownTask.cancel(); + } + this.countdownTask = new CountdownTimerTask(PlatformServices.getInstance().getRoundEndSeconds()); + timer.schedule(this.countdownTask, 0L, 1000L); + } + } else if (this.sessionState == 3 && this.countdownTask.value11 == 0) { + this.sessionState = 4; + } + Thread.yield(); + } catch (Exception e) { + r0.printStackTrace(); + } + } + if (this.sessionState == 4) { + onSessionEnd(); + } + if (this.sessionState == 5) { + cleanupNetworking(); + } + } + + /* renamed from: c */ + public abstract void onSessionStart(); + + /* renamed from: d */ + public abstract void onRoundStart(); + + /* renamed from: e */ + public abstract void onSessionEnd(); + + /* renamed from: f */ + public void cleanupNetworking() { + if (this.sessionType != 1) { + if (this.sessionType == 2) { + BluetoothDiscoveryClient.getInstance().bluetoothControlChannel233.execute138(); + } + } else { + BluetoothServerListener.getInstance_2().execute190(); + ConnectionManager c0035dM216a = ConnectionManager.getInstance_2(); + if (c0035dM216a != null) { + c0035dM216a.sendPacket223(); + ConnectionManager.execute217(); + } + } + } +} diff --git a/p000/GameplayCanvas.java b/p000/GameplayCanvas.java new file mode 100644 index 0000000..988aaa9 --- /dev/null +++ b/p000/GameplayCanvas.java @@ -0,0 +1,13 @@ +package p000; + +/* renamed from: z */ +/* loaded from: microcounterstrike.jar:z.class */ +public class GameplayCanvas extends GameRenderCanvas { + @Override // p000.GameRenderCanvas + /* renamed from: a */ + public final void execute19() { + ParticleEffectManager.getInstance().execute295(); + MuzzleFlashManager.getInstance().execute210(); + MapManager.getInstance().updateDecorations(); + } +} diff --git a/p000/GameplayKeyHandler.java b/p000/GameplayKeyHandler.java new file mode 100644 index 0000000..c1ea3a5 --- /dev/null +++ b/p000/GameplayKeyHandler.java @@ -0,0 +1,160 @@ +package p000; + +/* renamed from: at */ +/* loaded from: microcounterstrike.jar:at.class */ +public class GameplayKeyHandler extends KeyInputHandlerBase { + @Override // p000.KeyInputHandlerBase + /* renamed from: a */ + public final void execute127(int i, GameRenderCanvas c0002ab) { + Object obj = PlayerManager.getInstance().localPlayer; + int i2 = GameSessionLoop.getInstance().sessionState; + if (OverlayMenuBase.getInstance().flag192) { + if (i == 35 || i == -11) { + OverlayMenuBase.getInstance().execute35(); + return; + } + if (i != 48) { + OverlayMenuBase.getInstance().execute29(i, c0002ab.getGameAction(i)); + return; + } else { + if (OverlayMenuBase.getInstance().flag192 && OverlayMenuBase.getInstance().value191 == 1) { + OverlayMenuBase.getInstance().execute35(); + return; + } + return; + } + } + InputStateBase abstractC0019asM124b = InputStateBase.getInstance(); + if (i2 == 2) { + if (i == 50) { + abstractC0019asM124b.execute126(1, true); + } else if (i == 56) { + abstractC0019asM124b.execute126(2, true); + } else if (i == 52) { + abstractC0019asM124b.execute126(7, true); + } else if (i == 54) { + abstractC0019asM124b.execute126(8, true); + } else if (i == 53 || c0002ab.getGameAction(i) == 8) { + abstractC0019asM124b.execute126(0, true); + } else if (c0002ab.getGameAction(i) == 1) { + abstractC0019asM124b.execute126(1, true); + } else if (c0002ab.getGameAction(i) == 6) { + abstractC0019asM124b.execute126(2, true); + } else if (c0002ab.getGameAction(i) == 2) { + abstractC0019asM124b.execute126(7, true); + } else if (c0002ab.getGameAction(i) == 5) { + abstractC0019asM124b.execute126(8, true); + } else if (i == 49) { + abstractC0019asM124b.execute126(3, true); + } else if (i == 51) { + abstractC0019asM124b.execute126(4, true); + } else if (i == 57) { + Combatant interfaceC0030bc = (Combatant) obj; + if (interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode == 11 || interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode == 12) { + if (c0002ab.flag10) { + c0002ab.execute20(false); + } else { + c0002ab.execute20(true); + } + } + } + } + if (i == 48) { + abstractC0019asM124b.execute126(-1, false); + OverlayMenuBase.getInstance().value191 = 1; + OverlayMenuBase.getInstance().execute34(); + return; + } + if (i == 55) { + GameRenderCanvas.getInstance_2().execute20(false); + int i3 = ((Combatant) PlayerManager.getInstance().localPlayer).getLoadout().activeSlot; + for (int i4 = 0; i4 < 4; i4++) { + i3 = i3 == 4 ? 1 : i3 + 1; + if (((Combatant) obj).getLoadout().selectSlot(i3)) { + return; + } + } + return; + } + if (i != 42) { + if (i == 35 || i == -11) { + abstractC0019asM124b.execute126(-1, false); + OverlayMenuBase.getInstance().value191 = 0; + OverlayMenuBase.getInstance().execute34(); + return; + } + return; + } + int i5 = ((LocalPlayer) obj).money; + WeaponLoadout c0026azMo90k = ((Combatant) obj).getLoadout(); + int i6 = c0026azMo90k.activeSlot; + int iM173c = ((Combatant) obj).getLoadout().getActiveAmmo(); + int i7 = ((Combatant) obj).getLoadout().getActiveWeaponInfo().clipSize; + int i8 = iM173c / i7; + if (iM173c % i7 != 0) { + i8++; + } + WeaponInfo c0042k = null; + if (i6 == 1) { + z = i8 >= 4; + c0042k = (WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(WeaponLoadout.defaultAmmoPack1WeaponId); + } else if (i6 == 2) { + z = i8 >= 8; + c0042k = (WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(WeaponLoadout.defaultAmmoPack2WeaponId); + } + if (c0042k == null || c0042k.cost > i5 || z) { + return; + } + c0026azMo90k.addWeaponOrAmmo(c0042k); + ((LocalPlayer) obj).spendMoney(c0042k.cost); + HudBase.getInstance().execute237(6, (String) null); + } + + @Override // p000.KeyInputHandlerBase + /* renamed from: b */ + public final void execute128(int i, GameRenderCanvas c0002ab) { + if (OverlayMenuBase.getInstance().flag192) { + return; + } + InputStateBase abstractC0019asM124b = InputStateBase.getInstance(); + if (i == 50) { + abstractC0019asM124b.execute126(1, false); + return; + } + if (i == 56) { + abstractC0019asM124b.execute126(2, false); + return; + } + if (i == 52) { + abstractC0019asM124b.execute126(7, false); + return; + } + if (i == 54) { + abstractC0019asM124b.execute126(8, false); + return; + } + if (i == 53 || c0002ab.getGameAction(i) == 8) { + abstractC0019asM124b.execute126(0, false); + return; + } + if (c0002ab.getGameAction(i) == 1) { + abstractC0019asM124b.execute126(1, false); + return; + } + if (c0002ab.getGameAction(i) == 6) { + abstractC0019asM124b.execute126(2, false); + return; + } + if (c0002ab.getGameAction(i) == 2) { + abstractC0019asM124b.execute126(7, false); + return; + } + if (c0002ab.getGameAction(i) == 5) { + abstractC0019asM124b.execute126(8, false); + } else if (i == 49) { + abstractC0019asM124b.execute126(3, false); + } else if (i == 51) { + abstractC0019asM124b.execute126(4, false); + } + } +} diff --git a/p000/GrenadeController.java b/p000/GrenadeController.java new file mode 100644 index 0000000..24a2fba --- /dev/null +++ b/p000/GrenadeController.java @@ -0,0 +1,129 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.World; + +/* renamed from: af */ +/* loaded from: microcounterstrike.jar:af.class */ +public final class GrenadeController { + + /* renamed from: a */ + public PlayerEntityBase playerEntityBase49; + + /* renamed from: c */ + private static Image2D texture50; + + /* renamed from: d */ + private static float value51 = 2.5f; + + /* renamed from: e */ + private BillboardSprite billboardSprite52; + + /* renamed from: f */ + private float[] value53; + + /* renamed from: g */ + private float[] value54; + + /* renamed from: h */ + private int value55 = 0; + + /* renamed from: i */ + private boolean flag56 = true; + + /* renamed from: b */ + public int value57 = -1; + + public GrenadeController(PlayerEntityBase abstractC0052u) { + this.playerEntityBase49 = abstractC0052u; + } + + /* renamed from: a */ + public static void execute72() { + texture50 = ResourceLoader.loadImages132("/res/image2d/grenade.png"); + } + + /* renamed from: a */ + public final void execute73(World world, float[] fArr, float[] fArr2) { + this.flag56 = false; + this.value53 = fArr; + this.value57 = 0; + this.value54 = VectorMath.getFloatArray263(fArr2); + this.value54[0] = this.value54[0] * value51; + this.value54[1] = this.value54[1] * value51; + this.value54[2] = this.value54[2] * value51; + this.value55 = 0; + if (this.billboardSprite52 == null) { + this.billboardSprite52 = new BillboardSprite(texture50, world.getActiveCamera(), fArr[0], fArr[1], fArr[2], 0.3f); + world.addChild(this.billboardSprite52.mesh75); + this.billboardSprite52.mesh75.setPickingEnable(false); + } + this.billboardSprite52.mesh75.setTranslation(fArr[0], fArr[1], fArr[2]); + this.billboardSprite52.mesh75.setRenderingEnable(true); + } + + /* renamed from: a */ + public final void execute74(World world) { + if (this.flag56) { + return; + } + this.value57++; + float[] fArr = {this.value53[0] + (this.value54[0] * this.value55), this.value53[1] + (this.value54[1] * this.value55) + (0.5f * (-0.2f) * this.value55 * this.value55), this.value53[2] + (this.value54[2] * this.value55)}; + this.billboardSprite52.mesh75.setTranslation(fArr[0], fArr[1], fArr[2]); + this.billboardSprite52.execute106(); + this.value55++; + float[] fArrM263b = VectorMath.getFloatArray263(new float[]{this.value54[0], this.value54[1] + ((-0.2f) * this.value55), this.value54[2]}); + RayIntersection rayIntersection = new RayIntersection(); + world.pick(-1, fArr[0], fArr[1], fArr[2], fArrM263b[0], fArrM263b[1], fArrM263b[2], rayIntersection); + float distance = rayIntersection.getDistance(); + float[] fArr2 = {this.value53[0] + (this.value54[0] * this.value55), this.value53[1] + (this.value54[1] * this.value55) + (0.5f * (-0.2f) * this.value55 * this.value55), this.value53[2] + (this.value54[2] * this.value55)}; + if (((fArr2[0] - fArr[0]) * (fArr2[0] - fArr[0])) + ((fArr2[1] - fArr[1]) * (fArr2[1] - fArr[1])) + ((fArr2[2] - fArr[2]) * (fArr2[2] - fArr[2])) > distance * distance) { + this.billboardSprite52.mesh75.setRenderingEnable(false); + if (fArr[1] < 3.0f) { + fArr[1] = 3.0f; + } + ParticleEffectManager.getInstance().execute294(fArr, world, CameraManager.getInstance().camera89); + if (MainUiCanvasBase.getInstance().soundEnabled) { + SoundManager.getInstance().execute199(4); + } + if (PlayerManager.getInstance().localPlayer == this.playerEntityBase49) { + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + while (enumerationKeys.hasMoreElements()) { + PlayerEntityBase abstractC0052u = (PlayerEntityBase) hashtable.get((Integer) enumerationKeys.nextElement()); + if (abstractC0052u.value257 != 1) { + execute75(abstractC0052u, fArr); + } + } + } + this.flag56 = true; + this.value57 = -1; + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* renamed from: a */ + private void execute75(PlayerEntityBase abstractC0052u, float[] fArr) { + if (abstractC0052u != this.playerEntityBase49 && ((Combatant) abstractC0052u).getHealth() > 0) { + float[] fArrM289i = abstractC0052u.getFloatArray289(); + if (((fArrM289i[0] - fArr[0]) * (fArrM289i[0] - fArr[0])) + ((fArrM289i[1] - fArr[1]) * (fArrM289i[1] - fArr[1])) + ((fArrM289i[2] - fArr[2]) * (fArrM289i[2] - fArr[2])) < 36.0f) { + ((Combatant) abstractC0052u).onHit(this.playerEntityBase49, 4, null, null); + } + } + } + + /* renamed from: b */ + public final void execute76() { + this.value53 = null; + this.value54 = null; + this.billboardSprite52 = null; + } + + /* renamed from: c */ + public static void execute77() { + texture50 = null; + } +} diff --git a/p000/HudBase.java b/p000/HudBase.java new file mode 100644 index 0000000..a514f21 --- /dev/null +++ b/p000/HudBase.java @@ -0,0 +1,51 @@ +package p000; + +import javax.microedition.lcdui.Graphics; + +/* renamed from: i */ +/* loaded from: microcounterstrike.jar:i.class */ +public abstract class HudBase { + + /* renamed from: a */ + private static HudBase hudBase199; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [i] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [i] */ + /* renamed from: a */ + public static HudBase getInstance() { + ?? r0 = hudBase199; + if (r0 == 0) { + try { + r0 = (HudBase) PlatformServices.getInstance().getHudRendererClass().newInstance(); + hudBase199 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return hudBase199; + } + + /* renamed from: a */ + public abstract void execute236(Graphics graphics, GameRenderCanvas c0002ab); + + /* renamed from: a */ + public abstract void execute237(int i, String str); + + /* renamed from: b */ + public abstract void execute238(); + + /* renamed from: c */ + public static void execute239() { + PlatformServices.getInstance().loadHudResources(); + } + + /* renamed from: d */ + public static void execute240() { + PlatformServices.getInstance().unloadHudResources(); + } +} diff --git a/p000/HudRenderer.java b/p000/HudRenderer.java new file mode 100644 index 0000000..d13c699 --- /dev/null +++ b/p000/HudRenderer.java @@ -0,0 +1,544 @@ +package p000; + +import javax.microedition.lcdui.Font; +import javax.microedition.lcdui.Graphics; +import javax.microedition.lcdui.Image; + +/* renamed from: y */ +/* loaded from: microcounterstrike.jar:y.class */ +public class HudRenderer extends HudBase { + + /* renamed from: a */ + public int value287 = -1; + + /* renamed from: b */ + public int value288 = -1; + + /* renamed from: d */ + private String text290 = null; + + /* renamed from: e */ + private int value291 = -1; + + /* renamed from: f */ + private int value292 = 0; + + /* renamed from: T */ + private int f332T = 0; + + /* renamed from: U */ + private long f333U = 0; + + /* renamed from: c */ + private static String[] text289 = {"Preparing...", "Time Out!", "Counter-Terrorists Win!", "Terrorists Win!", "Out of ammunition.", "You already own that weapon.", "Buy successfully!", "Press 0 to purchase."}; + + /* renamed from: g */ + private static Image image293 = null; + + /* renamed from: h */ + private static Image image294 = null; + + /* renamed from: i */ + private static Image[] image295 = null; + + /* renamed from: j */ + private static Image[] image296 = null; + + /* renamed from: k */ + private static Image image297 = null; + + /* renamed from: l */ + private static Image image298 = null; + + /* renamed from: m */ + private static Image image299 = null; + + /* renamed from: n */ + private static Image image300 = null; + + /* renamed from: o */ + private static final int[] CONST_VALUE301 = new int[2]; + + /* renamed from: p */ + private static final int[] CONST_VALUE302 = {0, 10}; + + /* renamed from: q */ + private static final int[] CONST_VALUE303 = {10, 8}; + + /* renamed from: r */ + private static final int[] CONST_VALUE304 = {10, 8}; + + /* renamed from: s */ + private static final int[] CONST_VALUE305 = {10, 8}; + + /* renamed from: t */ + private static final int[] CONST_VALUE306 = {0, 10}; + + /* renamed from: u */ + private static final int[] CONST_VALUE307 = {9, 7}; + + /* renamed from: v */ + private static final int[] CONST_VALUE308 = {10, 8}; + + /* renamed from: w */ + private static final int[] CONST_VALUE309 = {19, 15}; + + /* renamed from: x */ + private static final int[] CONST_VALUE310 = {0, 10}; + + /* renamed from: y */ + private static final int[] CONST_VALUE311 = {2, 1}; + + /* renamed from: z */ + private static final int[] CONST_VALUE312 = {10, 5}; + + /* renamed from: A */ + private static final int[] f313A = {21, 16}; + + /* renamed from: B */ + private static final int[] f314B = {0, 10}; + + /* renamed from: C */ + private static final int[] f315C = {10, 8}; + + /* renamed from: D */ + private static final int[] f316D = {10, 8}; + + /* renamed from: E */ + private static final int[] f317E = {31, 24}; + + /* renamed from: F */ + private static final int[] f318F = {0, 10}; + + /* renamed from: G */ + private static final int[] f319G = {5, 4}; + + /* renamed from: H */ + private static final int[] f320H = {10, 7}; + + /* renamed from: I */ + private static final int[] f321I = {8, 14}; + + /* renamed from: J */ + private static final int[] f322J = {6, 5}; + + /* renamed from: K */ + private static final int[] f323K = {6, 5}; + + /* renamed from: L */ + private static final int[] f324L = new int[2]; + + /* renamed from: M */ + private static final int[] f325M = {0, 14}; + + /* renamed from: N */ + private static final int[] f326N = {8, 5}; + + /* renamed from: O */ + private static final int[] f327O = {8, 5}; + + /* renamed from: P */ + private static final int[] f328P = {80, 50}; + + /* renamed from: Q */ + private static final int[] f329Q = {0, 14}; + + /* renamed from: R */ + private static final int[] f330R = {2, 1}; + + /* renamed from: S */ + private static final int[] f331S = {8, 5}; + + @Override // p000.HudBase + /* renamed from: a */ + public final void execute236(Graphics graphics, GameRenderCanvas c0002ab) { + int width = c0002ab.getWidth(); + int height = c0002ab.getHeight(); + int i = PlatformServices.getInstance().uiLayoutMode; + Combatant interfaceC0030bc = (Combatant) PlayerManager.getInstance().localPlayer; + GameSessionLoop abstractRunnableC0014anM107a = GameSessionLoop.getInstance(); + if (interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode != 11) { + graphics.setColor(6553418); + int i2 = width / 2; + int i3 = height / 2; + if (InputStateBase.getInstance().flag93[0]) { + this.f332T++; + } else { + this.f332T--; + } + if (this.f332T > 5) { + this.f332T = 5; + } else if (this.f332T < 0) { + this.f332T = 0; + } + graphics.drawLine((((i2 - 3) - 3) + 1) - this.f332T, i3, (i2 - 3) - this.f332T, i3); + graphics.drawLine(i2 + 3 + this.f332T, i3, (((i2 + 3) + 3) - 1) + this.f332T, i3); + graphics.drawLine(i2, (((i3 - 3) - 3) + 1) - this.f332T, i2, (i3 - 3) - this.f332T); + graphics.drawLine(i2, i3 + 3 + this.f332T, i2, (((i3 + 3) + 3) - 1) + this.f332T); + } + if (this.value287 >= 0) { + Image[] imageArr = (Image[]) null; + int i4 = interfaceC0030bc.getLoadout().activeSlot; + float f = 0.8f; + if (i4 == 1) { + imageArr = image295; + } else if (i4 == 2) { + imageArr = image296; + f = 1.0f; + } + graphics.drawImage(imageArr[this.value287], width - ((int) (r0.recoilPattern[i][0][2] * f)), height - interfaceC0030bc.getLoadout().getActiveWeaponInfo().recoilPattern[i][0][3], 3); + this.value287++; + if (this.value287 >= imageArr.length) { + this.value287 = -1; + } + } + if (interfaceC0030bc.getHealth() > 0) { + if (interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode == 11 && c0002ab.flag10) { + graphics.setColor(0, 0, 0); + graphics.drawRegion(image294, 0, 0, image294.getWidth(), image294.getHeight(), 0, width / 2, height / 2, 40); + graphics.drawRegion(image294, 0, 0, image294.getWidth(), image294.getHeight(), 2, width / 2, height / 2, 36); + graphics.drawRegion(image294, 0, 0, image294.getWidth(), image294.getHeight(), 1, width / 2, height / 2, 24); + graphics.drawRegion(image294, 0, 0, image294.getWidth(), image294.getHeight(), 3, width / 2, height / 2, 20); + int height2 = (height / 2) - image294.getHeight(); + graphics.fillRect(0, 0, width, height2 + 2); + graphics.fillRect(0, height2 + (image294.getHeight() * 2), width, height2 + 1); + int width2 = (width / 2) - image294.getWidth(); + graphics.fillRect(0, height2 + 2, width2 + 1, image294.getHeight() * 2); + graphics.fillRect(width2 + (image294.getWidth() * 2), height2 + 2, width2 + 1, image294.getHeight() * 2); + int i5 = width / 2; + int i6 = height / 2; + graphics.setColor(255, 0, 0); + graphics.drawLine(i5 - 1, i6, i5 + 1, i6); + graphics.drawLine(i5, i6 - 1, i5, i6 + 1); + graphics.setColor(0); + graphics.drawLine(i5 - 6, i6, i5 - 6, i6); + graphics.drawLine(i5 + 6, i6, i5 + 6, i6); + graphics.drawLine(i5, i6 - 6, i5, i6 - 6); + graphics.drawLine(i5, i6 + 6, i5, i6 + 6); + graphics.drawLine(i5 - 8, i6, i5 - 8, i6); + graphics.drawLine(i5 + 8, i6, i5 + 8, i6); + graphics.drawLine(i5, i6 - 8, i5, i6 - 8); + graphics.drawLine(i5, i6 + 8, i5, i6 + 8); + graphics.drawLine(i5 - 11, i6, i5 - 11, i6); + graphics.drawLine(i5 + 11, i6, i5 + 11, i6); + graphics.drawLine(i5, i6 - 11, i5, i6 - 11); + graphics.drawLine(i5, i6 + 11, i5, i6 + 11); + int i7 = i == 0 ? 56 : 35; + graphics.drawLine((i5 - 15) - i7, i6, i5 - 15, i6); + graphics.drawLine(i5 + 15, i6, i5 + 15 + i7, i6); + graphics.drawLine(i5, (i6 - 15) - i7, i5, i6 - 15); + graphics.drawLine(i5, i6 + 15, i5, i6 + 15 + i7); + } else { + PlayerInputController c0039h = (PlayerInputController) InputStateBase.getInstance(); + WeaponInfo c0042kM174d = interfaceC0030bc.getLoadout().getActiveWeaponInfo(); + if (c0042kM174d.weaponCode == 30) { + int i8 = this.value288; + int i9 = i8; + if (i8 == -1) { + i9 = 0; + } + graphics.drawRegion(image293, c0042kM174d.recoilPattern[i][i9][0], c0042kM174d.recoilPattern[i][i9][1], c0042kM174d.recoilPattern[i][i9][2], c0042kM174d.recoilPattern[i][i9][3], 0, width, height + (3 * c0039h.value195), 40); + if (this.value288 >= 0) { + this.value288++; + if (this.value288 >= c0042kM174d.recoilPattern[i].length) { + this.value288 = -1; + } + } + } else { + int i10 = c0039h.value197; + if (i10 != 0) { + graphics.drawRegion(image293, c0042kM174d.recoilPattern[i][0][0], c0042kM174d.recoilPattern[i][0][1], c0042kM174d.recoilPattern[i][0][2], c0042kM174d.recoilPattern[i][0][3], 0, width + (3 * i10), height + (3 * i10), 40); + } else { + graphics.drawRegion(image293, c0042kM174d.recoilPattern[i][0][0], c0042kM174d.recoilPattern[i][0][1], c0042kM174d.recoilPattern[i][0][2], c0042kM174d.recoilPattern[i][0][3], 0, width, height + (3 * c0039h.value195), 40); + } + } + } + } + graphics.setColor(55, 195, 30); + graphics.setFont(Font.getFont(64, 1, 8)); + if (this.value291 != -1 && this.value292 < 30) { + this.value292++; + execute309(this.value291, graphics, width, height); + } + int i11 = i == 0 ? 16 : 12; + int i12 = i11; + int height3 = i11 / image298.getHeight(); + for (int i13 = 0; i13 < height3; i13++) { + graphics.drawRegion(image298, 0, 0, width, image298.getHeight(), 0, 0, height - (i13 * image298.getHeight()), 36); + } + int i14 = (i12 - CONST_VALUE303[i]) / 2; + int i15 = height - (i12 / 2); + graphics.drawRegion(image299, CONST_VALUE301[i], CONST_VALUE302[i], CONST_VALUE303[i], CONST_VALUE304[i], 0, i14, i15, 6); + int iMo89j = interfaceC0030bc.getHealth(); + int i16 = i14 + CONST_VALUE303[i] + 2 + (f322J[i] * 3); + int i17 = 1; + int i18 = 0; + while (true) { + int i19 = iMo89j / i17; + if (i19 == 0 && iMo89j != 0) { + break; + } + graphics.drawRegion(image300, f322J[i] * (i19 % 10), f321I[i], f322J[i], f323K[i], 0, i16 - (i18 * (f322J[i] + 1)), i15, 10); + if (iMo89j == 0) { + break; + } + i17 *= 10; + i18++; + } + int i20 = i == 0 ? 40 : 29; + graphics.drawRegion(image299, CONST_VALUE305[i], CONST_VALUE306[i], CONST_VALUE307[i], CONST_VALUE308[i], 0, i20, i15, 6); + int i21 = interfaceC0030bc.getLoadout().grenadeCharge; + int i22 = i20 + CONST_VALUE307[i] + 1 + (f322J[i] * 3); + int i23 = 1; + int i24 = 0; + while (true) { + int i25 = i21 / i23; + if (i25 == 0 && i21 != 0) { + break; + } + graphics.drawRegion(image300, f322J[i] * (i25 % 10), f321I[i], f322J[i], f323K[i], 0, i22 - (i24 * (f322J[i] + 1)), i15, 10); + if (i21 == 0) { + break; + } + i23 *= 10; + i24++; + } + if (interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode != 30) { + int i26 = width - i14; + graphics.drawRegion(image299, f313A[i], f314B[i], f315C[i], f316D[i], 0, i26, i15, 10); + int iM173c = interfaceC0030bc.getLoadout().getActiveAmmo(); + int i27 = interfaceC0030bc.getLoadout().getActiveWeaponInfo().clipSize; + int i28 = iM173c % i27; + int i29 = i28; + if (i28 == 0 && iM173c != 0) { + i29 = i27; + } + int i30 = iM173c - i29; + int i31 = (i26 - f315C[i]) - 2; + int i32 = 1; + int i33 = 0; + while (true) { + int i34 = i30 / i32; + if (i34 == 0 && i30 != 0) { + break; + } + graphics.drawRegion(image300, f322J[i] * (i34 % 10), f321I[i], f322J[i], f323K[i], 0, i31 - (i33 * (f322J[i] + 1)), i15, 10); + if (i30 == 0) { + break; + } + i32 *= 10; + i33++; + } + graphics.drawRegion(image299, CONST_VALUE309[i], CONST_VALUE310[i], CONST_VALUE311[i], CONST_VALUE312[i], 0, (i31 - (3 * (f322J[i] + 1))) - 1, i15, 10); + int i35 = 1; + int i36 = 0; + while (true) { + int i37 = i29 / i35; + if (i37 == 0 && i29 != 0) { + break; + } + graphics.drawRegion(image300, f322J[i] * (i37 % 10), f321I[i], f322J[i], f323K[i], 0, ((((i31 - (3 * (f322J[i] + 1))) - 1) - CONST_VALUE311[i]) - 2) - (i36 * (f322J[i] + 1)), i15, 10); + if (i29 == 0) { + break; + } + i35 *= 10; + i36++; + } + } + int i38 = 0; + int i39 = 0; + int i40 = abstractRunnableC0014anM107a.countdownTask.value11; + if (abstractRunnableC0014anM107a.sessionState == 1) { + i38 = 0; + i39 = 0; + i40 = abstractRunnableC0014anM107a.countdownTask.value11; + execute309(0, graphics, width, height); + } else if (abstractRunnableC0014anM107a.sessionState == 2) { + int i41 = abstractRunnableC0014anM107a.countdownTask.value11; + i38 = i41 / 60; + int i42 = i41 % 60; + i39 = i42 / 10; + i40 = i42 % 10; + } else if (abstractRunnableC0014anM107a.sessionState == 3) { + int i43 = abstractRunnableC0014anM107a.roundEndTriggered; + execute309(i43 == 0 ? 1 : i43 == 1 ? 2 : 3, graphics, width, height); + i38 = 0; + i39 = 0; + i40 = 0; + } else if (abstractRunnableC0014anM107a.sessionState == 5) { + i38 = 0; + i39 = 0; + i40 = 0; + } + int i44 = width / 2; + graphics.drawRegion(image300, f328P[i], f329Q[i], f330R[i], f331S[i], 0, i44, i15, 6); + graphics.drawRegion(image300, f324L[i] + (i38 * f326N[i]), f325M[i], f326N[i], f327O[i], 0, i44 - 2, i15, 10); + int i45 = i44 + f330R[i] + 2; + graphics.drawRegion(image300, f324L[i] + (i39 * f326N[i]), f325M[i], f326N[i], f327O[i], 0, i45, i15, 6); + graphics.drawRegion(image300, f324L[i] + (i40 * f326N[i]), f325M[i], f326N[i], f327O[i], 0, i45 + f326N[i] + 2, i15, 6); + int i46 = i14 + (f320H[i] / 2); + Image image = image299; + int i47 = f317E[i]; + int i48 = f318F[i]; + graphics.drawRegion(image, i47, i48, f319G[i], f320H[i], 0, ((width - i14) - (5 * (f322J[i] + 1))) - 2, i46, 10); + int i49 = ((LocalPlayer) interfaceC0030bc).money; + int i50 = 1; + int i51 = 0; + while (true) { + int i52 = i49 / i50; + if (i52 == 0 && i49 != 0) { + break; + } + Image image2 = image300; + int i53 = f322J[i]; + i48 = f321I[i]; + graphics.drawRegion(image2, i53 * (i52 % 10), i48, f322J[i], f323K[i], 0, (width - i14) - (i51 * (f322J[i] + 1)), i46, 10); + if (i49 == 0) { + break; + } + i50 *= 10; + i51++; + } + if (abstractRunnableC0014anM107a.sessionState == 1) { + int i54 = i48; + if (System.currentTimeMillis() - this.f333U < 500) { + execute308(7, graphics, width, height); + } + if (i54 - this.f333U >= 600) { + this.f333U = i54; + } + } + if (((LocalPlayer) interfaceC0030bc).tryConsumePainSoundCounter()) { + int height4 = height / image297.getHeight(); + if (height % image297.getHeight() != 0) { + height4++; + } + for (int i55 = 0; i55 < height4; i55++) { + graphics.drawRegion(image297, 0, 0, width, image297.getHeight(), 0, 0, i55 * image297.getHeight(), 20); + } + } + } + + /* renamed from: a */ + public final void execute308(int i, Graphics graphics, int i2, int i3) { + String lowerCase; + if (this.text290 != null) { + StringBuffer stringBuffer = new StringBuffer(); + stringBuffer.append(text289[i]); + stringBuffer.append(this.text290); + lowerCase = stringBuffer.toString().toLowerCase(); + } else { + lowerCase = text289[i].toLowerCase(); + } + int i4 = (i3 - (PlatformServices.getInstance().uiLayoutMode == 0 ? 16 : 12)) - 3; + int i5 = 3; + int[] iArr = new int[4]; + for (int i6 = 0; i6 < lowerCase.length(); i6++) { + MainMenuCanvas.execute68(lowerCase.charAt(i6), iArr); + if (iArr[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image41, iArr[0], iArr[1], iArr[2], iArr[3], 0, i5, i4, 36); + i5 += iArr[2] + 1; + } else if (i5 > i2 - 25) { + i5 = 3; + i4 = i4 + 6 + 3; + } else { + i5 += 6; + } + } + } + + /* renamed from: b */ + public final void execute309(int i, Graphics graphics, int i2, int i3) { + String lowerCase; + if (this.text290 != null) { + StringBuffer stringBuffer = new StringBuffer(); + stringBuffer.append(text289[i]); + stringBuffer.append(this.text290); + lowerCase = stringBuffer.toString().toLowerCase(); + } else { + lowerCase = text289[i].toLowerCase(); + } + int i4 = i3 / 4; + int i5 = 3; + int[] iArr = new int[4]; + for (int i6 = 0; i6 < lowerCase.length(); i6++) { + MainMenuCanvas.execute68(lowerCase.charAt(i6), iArr); + if (iArr[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i5, i4, 20); + i5 += iArr[2] + 1; + } else if (i5 > i2 - 25) { + i5 = 3; + i4 = i4 + 6 + 3; + } else { + i5 += 6; + } + } + } + + @Override // p000.HudBase + /* renamed from: a */ + public final void execute237(int i, String str) { + this.value292 = 0; + this.value291 = i; + this.text290 = str; + } + + /* renamed from: e */ + public final void execute310() { + if (!(((Combatant) PlayerManager.getInstance().localPlayer).getLoadout().getActiveWeaponInfo().weaponCode == 11 && GameRenderCanvas.getInstance_2().flag10) && this.value287 == -1) { + this.value287 = 0; + } + } + + /* renamed from: f */ + public final void execute311() { + if (this.value288 == -1) { + this.value288 = 0; + } + } + + @Override // p000.HudBase + /* renamed from: b */ + public final void execute238() { + this.text290 = null; + } + + /* renamed from: c */ + public static void loadImages312() { + int i = PlatformServices.getInstance().uiLayoutMode; + try { + if (i == 0) { + image294 = Image.createImage("/res/image2d/collimator.png"); + } else { + image294 = Image.createImage("/res/image2d/collimator_s.png"); + } + image295 = MuzzleFlashManager.image156; + image296 = MuzzleFlashManager.image158; + if (MainUiCanvasBase.getInstance().value183 != 0) { + image293 = Image.createImage("/res/image2d/weapon_handin_t.png"); + } else if (i == 0) { + image293 = Image.createImage("/res/image2d/weapon_handin.png"); + } else { + image293 = Image.createImage("/res/image2d/weapon_handin_s.png"); + } + image297 = Image.createImage("/res/image2d/fp_bloodspray.png"); + image298 = Image.createImage("/res/image2d/bg_mask.png"); + image299 = Image.createImage("/res/image2d/screen_symbol.png"); + image300 = Image.createImage("/res/image2d/screen_num.png"); + } catch (Exception unused) { + System.out.println("Failed to load 2D images"); + } + } + + /* renamed from: d */ + public static void execute313() { + text289 = null; + image294 = null; + image295 = null; + image296 = null; + image293 = null; + image298 = null; + image299 = null; + image300 = null; + } +} diff --git a/p000/InGameMenuOverlay.java b/p000/InGameMenuOverlay.java new file mode 100644 index 0000000..1c39f5d --- /dev/null +++ b/p000/InGameMenuOverlay.java @@ -0,0 +1,550 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import javax.microedition.lcdui.Font; +import javax.microedition.lcdui.Graphics; +import javax.microedition.lcdui.Image; + +/* renamed from: ad */ +/* loaded from: microcounterstrike.jar:ad.class */ +public class InGameMenuOverlay extends OverlayMenuBase { + + /* renamed from: d */ + private int value13 = 0; + + /* renamed from: e */ + private int value14 = 0; + + /* renamed from: i */ + private int value18 = 0; + + /* renamed from: o */ + private boolean flag24 = true; + + /* renamed from: p */ + private int value25 = 0; + + /* renamed from: c */ + private static final String[] CONST_TEXT12 = {"Resume", "Purchase", "Player list", "Quit"}; + + /* renamed from: f */ + private static Image image15 = null; + + /* renamed from: g */ + private static Image image16 = null; + + /* renamed from: h */ + private static Image image17 = null; + + /* renamed from: j */ + private static final int[] CONST_VALUE19 = {0, 4, 7}; + + /* renamed from: k */ + private static final String[] CONST_TEXT20 = {"primary", "secondary", "equipment"}; + + /* renamed from: l */ + private static final String[] CONST_TEXT21 = {"prima..", "secon..", "equip.."}; + + /* renamed from: m */ + private static final String[] CONST_TEXT22 = {"price:$", "clip capability:", "weight:"}; + + /* renamed from: n */ + private static final String[] CONST_TEXT23 = {"price:$", "clip c...:", "weight:"}; + + /* renamed from: a */ + public static void loadImages22() { + try { + image15 = Image.createImage("/res/image2d/bg_mask.png"); + int i = PlatformServices.getInstance().uiLayoutMode; + if (MainUiCanvasBase.getInstance().value183 != 0) { + image16 = Image.createImage("/res/image2d/weapons_t.png"); + } else if (i == 0) { + image16 = Image.createImage("/res/image2d/weapons.png"); + } else { + image16 = Image.createImage("/res/image2d/weapons_s.png"); + } + image17 = Image.createImage("/res/image2d/forbidden.png"); + } catch (Exception unused) { + System.out.println("Failed to load 2D images"); + } + } + + @Override // p000.OverlayMenuBase + /* renamed from: a */ + public final void execute23(Graphics graphics, GameRenderCanvas c0002ab) { + if (this.flag192) { + switch (this.value191) { + case 0: + execute25(graphics, c0002ab); + break; + case 1: + execute26(graphics, c0002ab); + break; + case 3: + execute27(graphics, c0002ab); + break; + case 4: + execute28(graphics, c0002ab); + break; + } + } + } + + /* renamed from: a */ + private static void execute24(Graphics graphics, int i, int i2) { + int height = i2 / image15.getHeight(); + if (i2 % image15.getHeight() != 0) { + height++; + } + for (int i3 = 0; i3 < height; i3++) { + graphics.drawRegion(image15, 0, 0, i, image15.getHeight(), 0, 0, i3 * image15.getHeight(), 20); + } + } + + /* renamed from: b */ + private void execute25(Graphics graphics, GameRenderCanvas c0002ab) { + execute24(graphics, c0002ab.getWidth(), c0002ab.getHeight()); + for (int i = 0; i < CONST_TEXT12.length; i++) { + String lowerCase = CONST_TEXT12[i].toLowerCase(); + int i2 = 15; + int[] iArr = new int[4]; + for (int i3 = 0; i3 < lowerCase.length(); i3++) { + MainMenuCanvas.execute68(lowerCase.charAt(i3), iArr); + if (iArr[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i2, 15 + (i * 14), 20); + i2 += iArr[2]; + } else { + i2 += 6; + } + } + if (i == this.value13) { + graphics.drawImage(MainMenuCanvas.image28, 6, 15 + (i * 14) + 3, 6); + } + } + } + + /* renamed from: c */ + private void execute26(Graphics graphics, GameRenderCanvas c0002ab) { + int width = c0002ab.getWidth(); + int height = c0002ab.getHeight(); + int i = PlatformServices.getInstance().uiLayoutMode; + execute24(graphics, width, height); + int i2 = i == 1 ? 6 : 22; + graphics.setColor(16685312); + graphics.fillRect(0, i2, width, 16); + int length = width / CONST_VALUE19.length; + int i3 = this.value18 * length; + graphics.setColor(0); + graphics.fillRect(i3, i2 + 1, length, 14); + String[] strArr = CONST_TEXT20; + if (i == 1) { + strArr = CONST_TEXT21; + } + for (int i4 = 0; i4 < strArr.length; i4++) { + String lowerCase = strArr[i4].toLowerCase(); + int length2 = (length * i4) + ((length - (lowerCase.length() * 6)) / 2); + int[] iArr = new int[4]; + for (int i5 = 0; i5 < lowerCase.length(); i5++) { + MainMenuCanvas.execute68(lowerCase.charAt(i5), iArr); + if (iArr[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, length2, i2 + 8, 6); + length2 += iArr[2]; + } else { + length2 += 6; + } + } + } + int i6 = i2 + 16 + 8; + int i7 = (height - i6) - i2; + Combatant interfaceC0030bc = (Combatant) PlayerManager.getInstance().localPlayer; + WeaponLoadout c0026azMo90k = interfaceC0030bc.getLoadout(); + int i8 = CONST_VALUE19[this.value18]; + int size = this.value18 == CONST_VALUE19.length - 1 ? WeaponLoadout.weaponCatalog.size() - i8 : CONST_VALUE19[this.value18 + 1] - i8; + if (this.value14 < i8 || this.value14 >= i8 + size) { + this.value14 = i8; + } + for (int i9 = i8; i9 < i8 + size; i9++) { + WeaponInfo c0042k = (WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(i9); + graphics.setColor(16685312); + graphics.fillRect(0, i6 + ((i9 - i8) * 15), 48, 14); + graphics.setColor(0); + if (i9 == this.value14) { + graphics.fillRect(0, i6 + ((i9 - i8) * 15) + 1, 47, 12); + } + String lowerCase2 = c0042k.name.toLowerCase(); + int i10 = 3; + int[] iArr2 = new int[4]; + for (int i11 = 0; i11 < lowerCase2.length(); i11++) { + MainMenuCanvas.execute68(lowerCase2.charAt(i11), iArr2); + if (iArr2[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr2[0], iArr2[1], iArr2[2], iArr2[3], 0, i10, i6 + ((i9 - i8) * 15) + 7, 6); + i10 += iArr2[2]; + } else { + i10 += 6; + } + } + } + graphics.setColor(16685312); + graphics.fillRect(0, i6 + (size * 15), 48, i7 - (size * 15)); + WeaponInfo c0042k2 = (WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(this.value14); + int i12 = i7 / 2; + graphics.setColor(16685312); + graphics.drawRect(50, i6, width - 48, i12); + graphics.drawRegion(image16, c0042k2.crosshairPattern[i][0], c0042k2.crosshairPattern[i][1], c0042k2.crosshairPattern[i][2], c0042k2.crosshairPattern[i][3], 0, width - (((width - 48) - 2) / 2), i6 + (i12 / 2), 3); + graphics.setColor(16685312); + graphics.drawRect(50, i6 + i12 + 3, width - 48, (i7 - i12) - 4); + StringBuffer stringBuffer = new StringBuffer(); + if (i == 1) { + stringBuffer.append(CONST_TEXT23[0]); + } else { + stringBuffer.append(CONST_TEXT22[0]); + } + stringBuffer.append(c0042k2.cost); + String string = stringBuffer.toString(); + int i13 = 56; + int[] iArr3 = new int[4]; + for (int i14 = 0; i14 < string.length(); i14++) { + MainMenuCanvas.execute68(string.charAt(i14), iArr3); + if (iArr3[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr3[0], iArr3[1], iArr3[2], iArr3[3], 0, i13, i6 + i12 + 8, 20); + i13 += iArr3[2]; + } else { + i13 += 6; + } + } + int i15 = c0042k2.weaponCode / 10; + if (i15 == 1 || i15 == 2) { + StringBuffer stringBuffer2 = new StringBuffer(); + if (i == 1) { + stringBuffer2.append(CONST_TEXT23[1]); + } else { + stringBuffer2.append(CONST_TEXT22[1]); + } + stringBuffer2.append(c0042k2.clipSize); + String string2 = stringBuffer2.toString(); + int i16 = 56; + int[] iArr4 = new int[4]; + for (int i17 = 0; i17 < string2.length(); i17++) { + MainMenuCanvas.execute68(string2.charAt(i17), iArr4); + if (iArr4[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr4[0], iArr4[1], iArr4[2], iArr4[3], 0, i16, i6 + i12 + 8 + 11, 20); + i16 += iArr4[2]; + } else { + i16 += 6; + } + } + StringBuffer stringBuffer3 = new StringBuffer(); + if (i == 1) { + stringBuffer3.append(CONST_TEXT23[2]); + } else { + stringBuffer3.append(CONST_TEXT22[2]); + } + stringBuffer3.append(c0042k2.weightLabel.toLowerCase()); + String string3 = stringBuffer3.toString(); + int i18 = 56; + int[] iArr5 = new int[4]; + for (int i19 = 0; i19 < string3.length(); i19++) { + MainMenuCanvas.execute68(string3.charAt(i19), iArr5); + if (iArr5[0] != -1) { + graphics.drawRegion(MainMenuCanvas.image40, iArr5[0], iArr5[1], iArr5[2], iArr5[3], 0, i18, i6 + i12 + 8 + 22, 20); + i18 += iArr5[2]; + } else { + i18 += 6; + } + } + } + boolean z = false; + if (c0042k2.cost > ((LocalPlayer) interfaceC0030bc).money) { + z = true; + } else if (c0042k2.weaponCode == 50) { + if (c0026azMo90k.equippedWeaponIdBySlot[0] == -1) { + z = true; + } + } else if (c0042k2.weaponCode == 51 && c0026azMo90k.equippedWeaponIdBySlot[1] == -1) { + z = true; + } + if (z) { + graphics.drawImage(image17, width - (((width - 48) - 2) / 2), i6 + (i12 / 2), 3); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* renamed from: d */ + private void execute27(Graphics graphics, GameRenderCanvas c0002ab) { + int width = c0002ab.getWidth(); + execute24(graphics, width, c0002ab.getHeight()); + graphics.setFont(Font.getFont(0, 0, 8)); + graphics.setColor(16777150); + graphics.drawString("Part Name", 10, 20, 36); + graphics.drawString("Life", width - 10, 22, 40); + graphics.setColor(5395026); + graphics.drawLine(10, 21, width - 10, 21); + graphics.setColor(15790320); + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + int i = 0; + while (enumerationKeys.hasMoreElements()) { + PlayerEntityBase abstractC0052u = (PlayerEntityBase) hashtable.get((Integer) enumerationKeys.nextElement()); + if (abstractC0052u.value257 != 1) { + if (((Combatant) abstractC0052u).getTeamId() == 1) { + graphics.drawString("T", 10, 23 + (i * 20), 20); + } else { + graphics.drawString("CT", 10, 23 + (i * 20), 20); + } + graphics.drawString(abstractC0052u.text256, 35, 23 + (i * 20), 20); + StringBuffer stringBuffer = new StringBuffer(); + stringBuffer.append(((Combatant) abstractC0052u).getHealth()); + graphics.drawString(stringBuffer.toString(), width - 10, 23 + (i * 20), 24); + i++; + } + } + } + + /* renamed from: e */ + private void execute28(Graphics graphics, GameRenderCanvas c0002ab) { + execute24(graphics, c0002ab.getWidth(), c0002ab.getHeight()); + graphics.setColor(16777215); + graphics.drawString("Sound", 10, 40, 20); + graphics.drawString(this.flag24 ? "On" : "Off", c0002ab.getWidth() - 20, 40, 24); + } + + @Override // p000.OverlayMenuBase + /* renamed from: a */ + public final void execute29(int i, int i2) { + if (this.flag192) { + switch (this.value191) { + case 0: + execute30(i, i2); + break; + case 1: + execute31(i, i2); + break; + case 3: + execute32(); + break; + case 4: + execute33(i, i2); + break; + } + } + } + + /* renamed from: b */ + private void execute30(int i, int i2) { + if (i == 50 || i2 == 1) { + if (this.value13 == 0) { + this.value13 = CONST_TEXT12.length - 1; + return; + } else { + this.value13--; + return; + } + } + if (i == 56 || i2 == 6) { + if (this.value13 == CONST_TEXT12.length - 1) { + this.value13 = 0; + return; + } else { + this.value13++; + return; + } + } + if (i != 53 && i2 != 8) { + if (i == -11) { + this.flag192 = false; + return; + } + return; + } + String str = CONST_TEXT12[this.value13]; + if (str.equals("Resume")) { + this.flag192 = false; + return; + } + if (str.equals("Purchase")) { + this.value191 = 1; + return; + } + if (str.equals("Player list")) { + this.value191 = 3; + return; + } + if (str.equals("Options")) { + this.flag24 = MainUiCanvasBase.getInstance().soundEnabled; + this.value191 = 4; + } else if (str.equals("Quit")) { + this.flag192 = false; + GameSessionLoop.getInstance().sessionState = 5; + MainUiCanvasBase abstractC0037fM227a = MainUiCanvasBase.getInstance(); + abstractC0037fM227a.value181 = 0; + abstractC0037fM227a.execute37(); + } + } + + /* renamed from: c */ + private void execute31(int i, int i2) { + WeaponLoadout.weaponCatalog.size(); + int length = CONST_VALUE19.length; + int i3 = CONST_VALUE19[this.value18]; + int size = this.value18 == CONST_VALUE19.length - 1 ? WeaponLoadout.weaponCatalog.size() - i3 : CONST_VALUE19[this.value18 + 1] - i3; + if (i == 52 || i2 == 2) { + if (this.value18 == 0) { + this.value18 = length - 1; + return; + } else { + this.value18--; + return; + } + } + if (i == 54 || i2 == 5) { + if (this.value18 == length - 1) { + this.value18 = 0; + return; + } else { + this.value18++; + return; + } + } + if (i == 50 || i2 == 1) { + if (this.value14 == i3) { + this.value14 = (i3 + size) - 1; + return; + } else { + this.value14--; + return; + } + } + if (i == 56 || i2 == 6) { + if (this.value14 == (i3 + size) - 1) { + this.value14 = i3; + return; + } else { + this.value14++; + return; + } + } + if (i == 53 || i2 == 8) { + Combatant interfaceC0030bc = (Combatant) PlayerManager.getInstance().localPlayer; + WeaponLoadout c0026azMo90k = interfaceC0030bc.getLoadout(); + WeaponInfo c0042k = (WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(this.value14); + if (c0042k.weaponId == c0026azMo90k.equippedWeaponIdBySlot[0] || c0042k.weaponId == c0026azMo90k.equippedWeaponIdBySlot[1] || c0042k.weaponId == c0026azMo90k.equippedWeaponIdBySlot[2]) { + HudBase.getInstance().execute237(5, (String) null); + execute35(); + return; + } + if (((LocalPlayer) interfaceC0030bc).money >= c0042k.cost) { + if (c0042k.weaponCode == 50) { + if (c0026azMo90k.equippedWeaponIdBySlot[0] != -1) { + int iM173c = interfaceC0030bc.getLoadout().getActiveAmmo(); + int i4 = interfaceC0030bc.getLoadout().getActiveWeaponInfo().clipSize; + int i5 = iM173c / i4; + if (iM173c % i4 != 0) { + i5++; + } + if (i5 < 4) { + c0026azMo90k.addWeaponOrAmmo(c0042k); + ((LocalPlayer) interfaceC0030bc).spendMoney(c0042k.cost); + HudBase.getInstance().execute237(6, (String) null); + } + execute35(); + return; + } + return; + } + if (c0042k.weaponCode != 51) { + c0026azMo90k.addWeaponOrAmmo(c0042k); + ((LocalPlayer) interfaceC0030bc).spendMoney(c0042k.cost); + GameRenderCanvas.getInstance_2().execute20(false); + HudBase.getInstance().execute237(6, (String) null); + execute35(); + return; + } + if (c0026azMo90k.equippedWeaponIdBySlot[1] != -1) { + int iM173c2 = interfaceC0030bc.getLoadout().getActiveAmmo(); + int i6 = interfaceC0030bc.getLoadout().getActiveWeaponInfo().clipSize; + int i7 = iM173c2 / i6; + if (iM173c2 % i6 != 0) { + i7++; + } + if (i7 < 8) { + c0026azMo90k.addWeaponOrAmmo(c0042k); + ((LocalPlayer) interfaceC0030bc).spendMoney(c0042k.cost); + HudBase.getInstance().execute237(6, (String) null); + } + execute35(); + } + } + } + } + + /* renamed from: f */ + private void execute32() { + this.value191 = 0; + } + + /* renamed from: d */ + private void execute33(int i, int i2) { + if (i == 50 || i2 == 1) { + if (this.value25 == 0) { + this.value25 = 0; + return; + } else { + this.value25--; + return; + } + } + if (i == 56 || i2 == 6) { + if (this.value25 == 0) { + this.value25 = 0; + return; + } else { + this.value25++; + return; + } + } + if (i == 52 || i2 == 2) { + switch (this.value25) { + case 0: + this.flag24 = !this.flag24; + break; + } + } + if (i == 54 || i2 == 5) { + switch (this.value25) { + case 0: + this.flag24 = !this.flag24; + break; + } + } else if (i == 53 || i2 == 8) { + MainUiCanvasBase.getInstance().setSoundEnabled(this.flag24); + this.value191 = 0; + } else if (i == 35) { + this.flag24 = MainUiCanvasBase.getInstance().soundEnabled; + this.value191 = 0; + } + } + + @Override // p000.OverlayMenuBase + /* renamed from: d */ + public final void execute34() { + this.value13 = 0; + super.execute34(); + } + + @Override // p000.OverlayMenuBase + /* renamed from: e */ + public final void execute35() { + this.value13 = 0; + this.value14 = 0; + this.value18 = 0; + super.execute35(); + } + + /* renamed from: b */ + public static void execute36() { + image15 = null; + image17 = null; + image16 = null; + } +} diff --git a/p000/InputStateBase.java b/p000/InputStateBase.java new file mode 100644 index 0000000..94e7911 --- /dev/null +++ b/p000/InputStateBase.java @@ -0,0 +1,47 @@ +package p000; + +/* renamed from: as */ +/* loaded from: microcounterstrike.jar:as.class */ +public abstract class InputStateBase { + + /* renamed from: a */ + private static InputStateBase inputStateBase92; + + /* renamed from: c */ + public boolean[] flag93; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [as] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [as] */ + /* renamed from: b */ + public static InputStateBase getInstance() { + ?? r0 = inputStateBase92; + if (r0 == 0) { + try { + r0 = (InputStateBase) PlatformServices.getInstance().getPlayerInputControllerClass().newInstance(); + inputStateBase92 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return inputStateBase92; + } + + /* renamed from: a */ + public abstract void execute125(); + + /* renamed from: a */ + public void execute126(int i, boolean z) { + if (i != -1) { + this.flag93[i] = z; + return; + } + for (int i2 = 0; i2 < this.flag93.length; i2++) { + this.flag93[i2] = z; + } + } +} diff --git a/p000/KeyInputHandlerBase.java b/p000/KeyInputHandlerBase.java new file mode 100644 index 0000000..5b94678 --- /dev/null +++ b/p000/KeyInputHandlerBase.java @@ -0,0 +1,36 @@ +package p000; + +/* renamed from: j */ +/* loaded from: microcounterstrike.jar:j.class */ +public abstract class KeyInputHandlerBase { + + /* renamed from: a */ + private static KeyInputHandlerBase keyInputHandlerBase200; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [j] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [j] */ + /* renamed from: a */ + public static KeyInputHandlerBase getInstance() { + ?? r0 = keyInputHandlerBase200; + if (r0 == 0) { + try { + r0 = (KeyInputHandlerBase) PlatformServices.getInstance().getGameplayKeyHandlerClass().newInstance(); + keyInputHandlerBase200 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return keyInputHandlerBase200; + } + + /* renamed from: a */ + public abstract void execute127(int i, GameRenderCanvas c0002ab); + + /* renamed from: b */ + public abstract void execute128(int i, GameRenderCanvas c0002ab); +} diff --git a/p000/LicenseInputForm.java b/p000/LicenseInputForm.java new file mode 100644 index 0000000..6ecbfa2 --- /dev/null +++ b/p000/LicenseInputForm.java @@ -0,0 +1,85 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import javax.microedition.lcdui.Command; +import javax.microedition.lcdui.CommandListener; +import javax.microedition.lcdui.Displayable; +import javax.microedition.lcdui.Form; +import javax.microedition.lcdui.TextField; +import javax.microedition.midlet.MIDletStateChangeException; +import javax.microedition.rms.RecordStore; +import javax.microedition.rms.RecordStoreException; +import javax.microedition.rms.RecordStoreFullException; +import javax.microedition.rms.RecordStoreNotFoundException; + +/* renamed from: ao */ +/* loaded from: microcounterstrike.jar:ao.class */ +public final class LicenseInputForm extends Form implements CommandListener { + + /* renamed from: a */ + private TextField textField82; + + /* renamed from: b */ + private TextField textField83; + + /* renamed from: c */ + private Command command84; + + /* renamed from: d */ + private Command command85; + + public LicenseInputForm() { + super("Registration"); + this.textField82 = null; + this.textField83 = null; + this.command84 = null; + this.command85 = null; + this.textField82 = new TextField("Your email:", (String) null, 100, 0); + append(this.textField82); + this.textField83 = new TextField("Serial number:", (String) null, 100, 2); + append(this.textField83); + this.command84 = new Command("OK", 1, 1); + addCommand(this.command84); + this.command85 = new Command("Exit", 1, 2); + addCommand(this.command85); + setCommandListener(this); + } + + public final void commandAction(Command command, Displayable displayable) { + if (command != this.command84) { + Command commandM213a = command; + if (commandM213a == this.command85) { + try { + SplashScreen.execute226(); + commandM213a = GameAppMidlet.getInstance(); + commandM213a.destroyApp(false); + } catch (MIDletStateChangeException e) { + commandM213a.printStackTrace(); + } + GameAppMidlet.getInstance().notifyDestroyed(); + return; + } + return; + } + if (!LicenseKeyUtil.getString100(this.textField82.getString()).equals(this.textField83.getString())) { + setTitle("Invalid Email/SN!"); + return; + } + RecordStore recordStore = null; + try { + RecordStore recordStoreOpenRecordStore = RecordStore.openRecordStore("m3gworksMCS", true); + byte[] bytes = "ZHANGYUNZHI".getBytes(); + recordStoreOpenRecordStore.addRecord(bytes, 0, bytes.length); + recordStore = recordStoreOpenRecordStore; + recordStore.closeRecordStore(); + } catch (RecordStoreNotFoundException e2) { + recordStore.printStackTrace(); + } catch (RecordStoreFullException e3) { + recordStore.printStackTrace(); + } catch (RecordStoreException e4) { + recordStore.printStackTrace(); + } + GameAppMidlet.getInstance().display.setCurrent(MainUiCanvasBase.getInstance()); + MainUiCanvasBase.getInstance().execute37(); + } +} diff --git a/p000/LicenseKeyUtil.java b/p000/LicenseKeyUtil.java new file mode 100644 index 0000000..9ef908b --- /dev/null +++ b/p000/LicenseKeyUtil.java @@ -0,0 +1,31 @@ +package p000; + +/* renamed from: ak */ +/* loaded from: microcounterstrike.jar:ak.class */ +public final class LicenseKeyUtil { + /* renamed from: a */ + public static final String getString100(String str) { + if (str == null) { + return "0"; + } + int length = str.toLowerCase().getBytes().length; + long jM101a = 0; + for (int i = 0; i < length; i++) { + jM101a += r0[i] * getLong101((length - i) - 1); + } + if (jM101a < 0) { + jM101a = -jM101a; + } + String string = Long.toString(jM101a); + return string.length() < 8 ? new StringBuffer(String.valueOf(string)).append("22052007".substring(0, 8 - string.length())).toString() : string.substring(0, 8); + } + + /* renamed from: a */ + private static final long getLong101(int i) { + long j = 1; + for (int i2 = 0; i2 < i; i2++) { + j *= 10; + } + return j; + } +} diff --git a/p000/LocalPlayer.java b/p000/LocalPlayer.java new file mode 100644 index 0000000..3de9ce5 --- /dev/null +++ b/p000/LocalPlayer.java @@ -0,0 +1,242 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.World; + +/* renamed from: ah */ +/* loaded from: microcounterstrike.jar:ah.class */ +public final class LocalPlayer extends PlayerMovementEntity implements Combatant { + + /* renamed from: d */ + public int teamId; + + /* renamed from: e */ + public int health; + + /* renamed from: f */ + public WeaponLoadout loadout; + + /* renamed from: r */ + public GrenadeController grenadeController; + + /* renamed from: s */ + public int money; + + /* renamed from: t */ + private int painSoundCounter; + + public LocalPlayer(int i, String str, int i2, int i3, PlayerModelBase abstractC0048q) { + super(i, str, i3, abstractC0048q); + this.money = 1000; + this.painSoundCounter = 3; + this.teamId = i2; + } + + @Override // p000.PlayerMovementEntity, p000.PlayerEntityBase + /* renamed from: a */ + public final void addToWorld(World world) { + super.addToWorld(world); + if (this.loadout == null) { + this.loadout = new WeaponLoadout(); + } + if (this.grenadeController == null) { + this.grenadeController = new GrenadeController(this); + } + } + + @Override // p000.PlayerMovementEntity, p000.PlayerEntityBase + /* renamed from: a */ + public final void removeFromWorld() { + super.removeFromWorld(); + this.loadout.dispose(); + this.loadout = null; + this.grenadeController.execute76(); + this.grenadeController = null; + } + + @Override // p000.PlayerMovementEntity, p000.PlayerEntityBase + /* renamed from: b */ + public final void respawn() { + super.respawn(); + if (this.health <= 0) { + this.loadout.resetToDefaultLoadout(); + } + this.health = 100; + } + + @Override // p000.Combatant + /* renamed from: e */ + public final int handleAction() { + int i = this.loadout.activeSlot; + if (i != 3) { + this.loadout.consumeAmmo(); + } + World world = MapManager.getInstance().world; + if (i == 4) { + float[] fArrM289i = getFloatArray289(); + fArrM289i[1] = fArrM289i[1] * 1.2f; + this.grenadeController.execute73(world, fArrM289i, compute287(1, 1.0f)); + return 2; + } + RayIntersection rayIntersection = new RayIntersection(); + Camera camera = CameraManager.getInstance().camera89; + if (!world.pick(-1, 0.5f, 0.5f, camera, rayIntersection)) { + return 2; + } + float[] fArr = new float[6]; + rayIntersection.getRay(fArr); + float distance = rayIntersection.getDistance(); + float f = fArr[0] + (fArr[3] * distance); + float f2 = fArr[1] + (fArr[4] * distance); + float f3 = fArr[2] + (fArr[5] * distance); + Mesh intersected = rayIntersection.getIntersected(); + RemotePlayer c0032be = null; + Object userObject = intersected.getUserObject(); + if (userObject != null && (userObject instanceof RemotePlayer)) { + c0032be = (RemotePlayer) userObject; + } + if (c0032be != null) { + if (c0032be.value148 <= 0) { + return 2; + } + if (i == 3) { + float f4 = ((f - fArr[0]) * (f - fArr[0])) + ((f2 - fArr[1]) * (f2 - fArr[1])) + ((f3 - fArr[2]) * (f3 - fArr[2])); + float f5 = c0032be.sphereCollider262.value99 * 2.0f * 1.2f; + if (f4 > f5 * f5) { + return 2; + } + } + this.money += c0032be.onHit(this, this.loadout.activeSlot, rayIntersection, world) * 10; + if (c0032be.value148 > 0) { + return 1; + } + this.money += 500; + return 1; + } + if (intersected.getAppearance(0).getCompositingMode().getBlending() == 64) { + return 2; + } + if (i != 1 && i != 2) { + return 2; + } + if (PlatformServices.getInstance().getBoolean141()) { + BulletHoleManager.getInstance().compute304(1, rayIntersection, world); + } + if (PlatformServices.getInstance().getBoolean142()) { + ParticleEffectManager.getInstance().execute292(2, rayIntersection, world, camera); + } + if (!PlatformServices.getInstance().getBoolean143()) { + return 2; + } + ParticleEffectManager.getInstance().execute292(3, rayIntersection, world, camera); + return 2; + } + + @Override // p000.Combatant + /* renamed from: a */ + public final int onHit(PlayerEntityBase abstractC0052u, int i, RayIntersection rayIntersection, World world) { + RemotePlayer c0032be = (RemotePlayer) abstractC0052u; + int iNextInt = 0; + int i2 = c0032be.weaponLoadout149.activeSlot; + if (this.health > 0) { + if (i2 != 3) { + resetPainSoundCounter(); + } + if (i2 == 1) { + iNextInt = c0032be.weaponLoadout149.getActiveWeaponInfo().weaponCode == 11 ? this.health : RandomUtil.random237.nextInt(25); + } else if (i2 == 2) { + iNextInt = RandomUtil.random237.nextInt(15); + } else if (i2 == 3) { + iNextInt = RandomUtil.random237.nextInt(20); + } else if (i2 == 4) { + iNextInt = RandomUtil.random237.nextInt(6) * 20; + } + iNextInt = iNextInt == 0 ? 1 : iNextInt; + if (this.loadout.grenadeCharge > 0) { + this.loadout.grenadeCharge -= iNextInt - (iNextInt / 3); + this.loadout.grenadeCharge = this.loadout.grenadeCharge < 0 ? 0 : this.loadout.grenadeCharge; + iNextInt /= 3; + } + applyDamage(iNextInt); + } + if (this.health <= 0) { + ((RoundBasedGameMode) GameSessionLoop.getInstance()).execute123(this); + } + return iNextInt; + } + + /* JADX WARN: Multi-variable type inference failed */ + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public final PlayerEntityBase findHitTarget(SphereCollider c0023aw) { + PlayerEntityBase abstractC0052u = null; + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + while (true) { + if (!enumerationKeys.hasMoreElements()) { + break; + } + PlayerEntityBase abstractC0052u2 = (PlayerEntityBase) hashtable.get((Integer) enumerationKeys.nextElement()); + if (((Combatant) abstractC0052u2).getHealth() > 0 && abstractC0052u2 != this && abstractC0052u2.sphereCollider262.getBoolean139(c0023aw)) { + abstractC0052u = abstractC0052u2; + break; + } + } + return abstractC0052u; + } + + /* renamed from: a */ + public final void spendMoney(int i) { + this.money -= i; + } + + /* renamed from: f */ + public final void resetPainSoundCounter() { + this.painSoundCounter = 0; + } + + /* renamed from: g */ + public final boolean tryConsumePainSoundCounter() { + if (this.painSoundCounter >= 3) { + return false; + } + this.painSoundCounter++; + return true; + } + + /* renamed from: b */ + private void applyDamage(int i) { + this.health -= i; + if (this.health < 0) { + this.health = 0; + } + } + + @Override // p000.Combatant + /* renamed from: j */ + public final int getHealth() { + return this.health; + } + + @Override // p000.Combatant + /* renamed from: k */ + public final WeaponLoadout getLoadout() { + return this.loadout; + } + + @Override // p000.Combatant + /* renamed from: l */ + public final GrenadeController getGrenadeController() { + return this.grenadeController; + } + + @Override // p000.Combatant + /* renamed from: m */ + public final int getTeamId() { + return this.teamId; + } +} diff --git a/p000/MainMenuCanvas.java b/p000/MainMenuCanvas.java new file mode 100644 index 0000000..ba09dd7 --- /dev/null +++ b/p000/MainMenuCanvas.java @@ -0,0 +1,1225 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import java.io.IOException; +import java.util.Vector; +import javax.bluetooth.ServiceRecord; +import javax.microedition.lcdui.Image; +import javax.microedition.midlet.MIDletStateChangeException; + +/* renamed from: ae */ +/* loaded from: microcounterstrike.jar:ae.class */ +public class MainMenuCanvas extends MainUiCanvasBase { + + /* renamed from: m */ + public static Image image28; + + /* renamed from: n */ + public static Image image39; + + /* renamed from: o */ + public static Image image40; + + /* renamed from: p */ + public static Image image41; + + /* renamed from: q */ + private static Image image26 = null; + + /* renamed from: r */ + private static Image image27 = null; + + /* renamed from: v */ + private static final String[] CONST_TEXT32 = {"start", "Multiplayer", "help", "about", "exit"}; + + /* renamed from: w */ + private static final String[] CONST_TEXT33 = {"forward:2,up", "backward:8,down", "turn left:4,left", "turn right:6,right", "move left:1", "move right:3", "shoot:5,fire", "change weapon:7", "collimator on/off:9", "buy:0", "buy ammos:*", "popup menu:#"}; + + /* renamed from: x */ + private static final String[] CONST_TEXT34 = {"micro counter strike", "full version 1.1.0", "", "produced by:", "www.m3gworks.com", "", "contact us:", "m3gworks@hotmail.com", "", "copyright^2007", "m3gworks team"}; + + /* renamed from: y */ + private static final String[] CONST_TEXT35 = {"counter-terrorist", "terrorist"}; + + /* renamed from: z */ + private static final String[] CONST_TEXT36 = {"host", "connect"}; + + /* renamed from: A */ + private static final String[] f37A = {"refresh", "quit"}; + + /* renamed from: B */ + private static final String[] f38B = {"start", "quit"}; + + /* renamed from: s */ + private int value29 = 0; + + /* renamed from: t */ + private boolean flag30 = true; + + /* renamed from: u */ + private int value31 = 0; + + /* renamed from: C */ + private int f42C = 0; + + /* renamed from: D */ + private int f43D = 0; + + /* renamed from: E */ + private int f44E = 0; + + /* renamed from: F */ + private boolean f45F = false; + + /* renamed from: G */ + private int f46G = 0; + + /* renamed from: H */ + private int f47H = 0; + + /* renamed from: I */ + private boolean f48I = false; + + @Override // p000.MainUiCanvasBase + /* renamed from: b */ + public final void execute37() { + switch (this.value181) { + case 0: + execute40(); + break; + case 1: + execute44(); + break; + case 2: + execute46(); + break; + case 3: + execute48(); + break; + case 4: + execute50(); + break; + case 5: + execute42(); + break; + case 9: + execute52(); + break; + case 10: + execute54(); + break; + case 12: + execute56(); + break; + case 13: + execute58(); + break; + case 14: + execute59(); + break; + case 21: + execute61(); + break; + case 22: + execute62(); + break; + case 23: + execute64(); + break; + case 24: + execute65(); + break; + case 25: + execute66(); + break; + } + } + + @Override // p000.MainUiCanvasBase + public void keyPressed(int i) { + switch (this.value181) { + case 0: + execute41(i); + break; + case 1: + execute45(i); + break; + case 2: + execute47(i); + break; + case 3: + execute49(i); + break; + case 4: + execute51(i); + break; + case 5: + execute43(i); + break; + case 10: + execute55(i); + break; + case 12: + execute57(i); + break; + case 14: + execute60(); + break; + case 22: + execute63(i); + break; + case 25: + execute67(); + break; + } + } + + /* renamed from: b */ + private void execute38(String str) { + this.graphics.setColor(16685312); + this.graphics.fillRect(0, 0, getWidth(), getHeight()); + this.graphics.setColor(0); + int width = (int) (getWidth() * 2.5568182f); + int height = (int) (getHeight() * 1.8181819f); + this.graphics.fillArc((getWidth() - width) - 2, -((height - getHeight()) / 3), width, height, 90, -160); + int i = 15; + int i2 = 18; + if (PlatformServices.getInstance().uiLayoutMode == 1) { + i = 8; + i2 = 12; + } + this.graphics.setColor(0); + this.graphics.drawLine(0, i - 1, getWidth(), i - 1); + for (int i3 = 0; i3 < i2; i3++) { + this.graphics.setColor(255 - (i3 * 3), 255 - (i3 * 3), 255 - (i3 * 3)); + this.graphics.fillRect(0, i + i3, getWidth(), 1); + } + this.graphics.setColor(0); + this.graphics.drawLine(0, i + i2, getWidth(), i + i2); + int i4 = i + ((i2 - 8) / 2); + int i5 = 10; + int[] iArr = new int[4]; + for (int i6 = 0; i6 < str.length(); i6++) { + execute69(str.charAt(i6), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image39, iArr[0], iArr[1], iArr[2], iArr[3], 0, i5, i4, 20); + i5 += iArr[2] + 1; + } else { + i5 += 8; + } + } + } + + /* renamed from: a */ + private void execute39(String[] strArr) { + int height = getHeight(); + int i = PlatformServices.getInstance().uiLayoutMode; + this.flag30 = false; + int i2 = this.value31; + while (true) { + if (i2 >= strArr.length) { + break; + } + String str = strArr[i2]; + int i3 = 10; + int i4 = (i == 1 ? 30 : 43) + ((i2 - this.value31) * 16); + if (i4 > height - 20) { + this.flag30 = true; + break; + } + int[] iArr = new int[4]; + for (int i5 = 0; i5 < str.length(); i5++) { + execute68(str.charAt(i5), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i3, i4, 20); + i3 += iArr[2]; + } else { + i3 += 6; + } + } + i2++; + } + if (this.value31 != 0) { + this.graphics.drawRegion(image28, 0, 0, image28.getWidth(), image28.getHeight(), 6, 10, i == 1 ? 25 : 38, 17); + } + if (this.flag30) { + this.graphics.drawRegion(image28, 0, 0, image28.getWidth(), image28.getHeight(), 5, 10, height - 10, 17); + } + } + + /* renamed from: e */ + private void execute40() { + Image image; + execute38("menu"); + if (PlatformServices.getInstance().uiLayoutMode == 1) { + image = image27; + image26 = null; + } else { + image = image26; + image27 = null; + } + this.graphics.drawImage(image, getWidth() / 2, getHeight() - 5, 33); + for (int i = 0; i < CONST_TEXT32.length; i++) { + String lowerCase = CONST_TEXT32[i].toLowerCase(); + int i2 = 10; + int i3 = (PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43) + (i * 14); + int[] iArr = new int[4]; + for (int i4 = 0; i4 < lowerCase.length(); i4++) { + execute68(lowerCase.charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i2, i3, 20); + i2 += iArr[2]; + } else { + i2 += 6; + } + } + if (i == this.value29) { + this.graphics.drawImage(image28, 4, i3 + 3, 6); + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v17, types: [int] */ + /* JADX WARN: Type inference failed for: r0v18, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v21, types: [com.m3gworks.engine.GameAppMidlet] */ + /* renamed from: a */ + private void execute41(int i) { + if (i == 50 || getGameAction(i) == 1) { + if (this.value29 == 0) { + this.value29 = CONST_TEXT32.length - 1; + } else { + this.value29--; + } + } else if (i == 56 || getGameAction(i) == 6) { + if (this.value29 == CONST_TEXT32.length - 1) { + this.value29 = 0; + } else { + this.value29++; + } + } else if (i == 53 || getGameAction(i) == 8) { + ?? M213a = this.value29; + switch (M213a) { + case 0: + this.sessionType = 0; + GameSessionLoop.getInstance().sessionType = this.sessionType; + this.value181 = 5; + break; + case 1: + this.value181 = 10; + break; + case 2: + this.value181 = 3; + break; + case 3: + this.value181 = 4; + break; + case 4: + try { + GameLoadingThread.getInstance(); + GameLoadingThread.execute99(); + SplashScreen.execute226(); + M213a = GameAppMidlet.getInstance(); + M213a.destroyApp(false); + } catch (MIDletStateChangeException e) { + M213a.printStackTrace(); + } + GameAppMidlet.getInstance().notifyDestroyed(); + return; + } + } + execute37(); + } + + /* renamed from: f */ + private void execute42() { + execute38("select team"); + for (int i = 0; i < CONST_TEXT35.length; i++) { + String lowerCase = CONST_TEXT35[i].toLowerCase(); + int i2 = 10; + int i3 = (PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43) + (i * 14); + int[] iArr = new int[4]; + for (int i4 = 0; i4 < lowerCase.length(); i4++) { + execute68(lowerCase.charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i2, i3, 20); + i2 += iArr[2]; + } else { + i2 += 6; + } + } + if (i == this.f42C) { + this.graphics.drawImage(image28, 4, i3 + 3, 6); + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: b */ + private void execute43(int i) { + if (i == 56 || getGameAction(i) == 1) { + if (this.f42C == 0) { + this.f42C = CONST_TEXT35.length - 1; + } else { + this.f42C--; + } + } else if (i == 50 || getGameAction(i) == 6) { + if (this.f42C == CONST_TEXT35.length - 1) { + this.f42C = 0; + } else { + this.f42C++; + } + } else if (i == 53 || getGameAction(i) == 8) { + if (this.f42C == 0) { + this.value183 = 0; + } else { + this.value183 = 1; + } + this.value181 = 1; + } else if (i == 35) { + this.f42C = 0; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: g */ + private void execute44() { + execute38("choose a map"); + Vector vector = MapManager.getInstance().maps; + for (int i = 0; i < vector.size(); i++) { + String lowerCase = ((MapInfo) vector.elementAt(i)).displayName.toLowerCase(); + int i2 = 10; + int i3 = PlatformServices.getInstance().uiLayoutMode; + int i4 = (i3 == 1 ? 30 : 43) + (i * 14); + int[] iArr = new int[4]; + for (int i5 = 0; i5 < lowerCase.length(); i5++) { + execute68(lowerCase.charAt(i5), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i2, i4, 20); + i2 += iArr[2]; + } else { + i2 += 6; + } + } + if (i == this.value182) { + this.graphics.drawImage(image28, 4, (i3 == 1 ? 30 : 43) + (i * 14) + 3, 6); + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: c */ + private void execute45(int i) { + Vector vector = MapManager.getInstance().maps; + if (i == 56 || getGameAction(i) == 1) { + if (this.value182 == 0) { + this.value182 = vector.size() - 1; + } else { + this.value182--; + } + } else if (i == 50 || getGameAction(i) == 6) { + if (this.value182 == vector.size() - 1) { + this.value182 = 0; + } else { + this.value182++; + } + } else if (i == 53 || getGameAction(i) == 8) { + MapManager.getInstance().currentMapIndex = this.value182; + switch (this.sessionType) { + case 0: + GameLoadingThread.getInstance(); + GameLoadingThread.execute94(); + GameLoadingThread.getInstance(); + GameLoadingThread.showScreen95(); + return; + case 1: + BluetoothServerListener.getInstance().execute189(); + this.value181 = 12; + break; + } + } else if (i == 35) { + this.value182 = 0; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: h */ + private void execute46() { + execute38("options"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i3 = 0; i3 < "sound".length(); i3++) { + execute68("sound".charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + this.graphics.drawRegion(image28, 0, 0, image28.getWidth(), image28.getHeight(), 3, getWidth() - 40, i2 + 3, 24); + String str = this.soundEnabledPending ? "on" : "off"; + int width = getWidth() - 35; + for (int i4 = 0; i4 < str.length(); i4++) { + execute68(str.charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, width, i2, 20); + width += iArr[2]; + } else { + width += 6; + } + } + this.graphics.drawRegion(image28, 0, 0, image28.getWidth(), image28.getHeight(), 0, getWidth() - 10, i2 + 3, 24); + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: d */ + private void execute47(int i) { + if (i == 50 || getGameAction(i) == 1) { + if (this.value187 == 0) { + this.value187 = 0; + } else { + this.value187--; + } + } else if (i == 56 || getGameAction(i) == 6) { + if (this.value187 == 0) { + this.value187 = 0; + } else { + this.value187++; + } + } else if (i == 52 || getGameAction(i) == 2) { + switch (this.value187) { + case 0: + this.soundEnabledPending = !this.soundEnabledPending; + break; + } + } else if (i == 54 || getGameAction(i) == 5) { + switch (this.value187) { + case 0: + this.soundEnabledPending = !this.soundEnabledPending; + break; + } + } else if (i == 53 || getGameAction(i) == 8) { + this.soundEnabled = this.soundEnabledPending; + this.value181 = 0; + } else if (i == 35 || i == -11) { + this.soundEnabledPending = this.soundEnabled; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: i */ + private void execute48() { + execute38("help"); + execute39(CONST_TEXT33); + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: e */ + private void execute49(int i) { + if (i == 50 || getGameAction(i) == 1) { + this.value31--; + if (this.value31 < 0) { + this.value31 = 0; + } + } else if (i == 56 || getGameAction(i) == 6) { + if (this.flag30) { + this.value31++; + if (this.value31 > CONST_TEXT33.length - 1) { + this.value31 = CONST_TEXT33.length - 1; + } + } + } else if (i == 53 || i == 35 || getGameAction(i) == 8 || i == -11) { + this.value31 = 0; + this.flag30 = true; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: j */ + private void execute50() { + execute38("about"); + execute39(CONST_TEXT34); + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: f */ + private void execute51(int i) { + if (i == 50 || getGameAction(i) == 1) { + this.value31--; + if (this.value31 < 0) { + this.value31 = 0; + } + } else if (i == 56 || getGameAction(i) == 6) { + if (this.flag30) { + this.value31++; + if (this.value31 > CONST_TEXT33.length - 1) { + this.value31 = CONST_TEXT33.length - 1; + } + } + } else if (i == 53 || i == 35 || getGameAction(i) == 8 || i == -11) { + this.value31 = 0; + this.flag30 = true; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: k */ + private void execute52() { + this.graphics.setColor(0, 0, 0); + this.graphics.fillRect(0, 0, getWidth(), getHeight()); + int height = getHeight() - 20; + int width = getWidth() - 40; + this.graphics.setColor(16685312); + this.graphics.fillRect(20, height, (int) (width * (GameLoadingThread.getInstance().value71 / 100.0f)), 5); + this.graphics.setColor(1250067); + this.graphics.drawRect(20, height, width, 5); + flushGraphics(); + } + + @Override // p000.MainUiCanvasBase + /* renamed from: a */ + public final void showScreen53(String str) { + this.graphics.setColor(0, 0, 0); + this.graphics.fillRect(0, 0, getWidth(), getHeight()); + this.graphics.setColor(255, 255, 255); + this.graphics.drawString(str, 0, 0, 20); + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: l */ + private void execute54() { + execute38("host or connect"); + for (int i = 0; i < CONST_TEXT36.length; i++) { + String lowerCase = CONST_TEXT36[i].toLowerCase(); + int i2 = 10; + int i3 = (PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43) + (i * 14); + int[] iArr = new int[4]; + for (int i4 = 0; i4 < lowerCase.length(); i4++) { + execute68(lowerCase.charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i2, i3, 20); + i2 += iArr[2]; + } else { + i2 += 6; + } + } + if (i == this.f43D) { + this.graphics.drawImage(image28, 4, i3 + 3, 6); + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: g */ + private void execute55(int i) { + if (i == 56 || getGameAction(i) == 1) { + if (this.f43D == 0) { + this.f43D = CONST_TEXT36.length - 1; + } else { + this.f43D--; + } + } else if (i == 50 || getGameAction(i) == 6) { + if (this.f43D == CONST_TEXT36.length - 1) { + this.f43D = 0; + } else { + this.f43D++; + } + } else if (i == 53 || getGameAction(i) == 8) { + switch (this.f43D) { + case 0: + this.sessionType = 1; + GameSessionLoop.getInstance().sessionType = this.sessionType; + this.value183 = 0; + this.value181 = 1; + break; + case 1: + this.sessionType = 2; + GameSessionLoop.getInstance().sessionType = this.sessionType; + this.value183 = 1; + GameLoadingThread.getInstance(); + GameLoadingThread.execute94(); + this.value181 = 21; + BluetoothDiscoveryClient.getInstance().execute267(); + break; + } + } else if (i == 35) { + this.f43D = 0; + this.value181 = 0; + } + execute37(); + } + + /* renamed from: m */ + private void execute56() { + String str; + String[] strArr; + execute38("host"); + ConnectionManager c0035dM216a = ConnectionManager.getInstance_2(); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + if (c0035dM216a != null) { + str = "client connected."; + this.f45F = true; + strArr = f38B; + } else { + str = "waiting for client..."; + this.f45F = false; + strArr = f37A; + } + int[] iArr = new int[4]; + for (int i3 = 0; i3 < str.length(); i3++) { + execute68(str.charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + int i4 = 60; + for (int i5 = 0; i5 < strArr.length; i5++) { + String lowerCase = strArr[i5].toLowerCase(); + int i6 = 10; + i4 += i5 * 14; + int[] iArr2 = new int[4]; + for (int i7 = 0; i7 < lowerCase.length(); i7++) { + execute68(lowerCase.charAt(i7), iArr2); + if (iArr2[0] != -1) { + this.graphics.drawRegion(image40, iArr2[0], iArr2[1], iArr2[2], iArr2[3], 0, i6, i4, 20); + i6 += iArr2[2]; + } else { + i6 += 6; + } + } + if (i5 == this.f44E) { + this.graphics.drawImage(image28, 4, i4 + 3, 6); + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: h */ + private void execute57(int i) { + if (i == 56 || getGameAction(i) == 1) { + if (this.f44E == 0) { + this.f44E = 1; + } else { + this.f44E = 0; + } + execute37(); + return; + } + if (i == 50 || getGameAction(i) == 6) { + if (this.f44E == 0) { + this.f44E = 1; + } else { + this.f44E = 0; + } + execute37(); + return; + } + if (i == 53 || getGameAction(i) == 8) { + if (this.f44E != 0) { + BluetoothServerListener.getInstance_2().execute190(); + ConnectionManager c0035dM216a = ConnectionManager.getInstance_2(); + if (c0035dM216a != null) { + c0035dM216a.sendPacket223(); + } + ConnectionManager.execute217(); + this.f44E = 0; + this.f45F = false; + this.value181 = 0; + execute37(); + return; + } + if (!this.f45F) { + execute37(); + return; + } + this.value181 = 13; + execute37(); + BluetoothServerListener runnableC0028baM187b = BluetoothServerListener.getInstance_2(); + runnableC0028baM187b.execute190(); + ConnectionManager c0035dM216a2 = ConnectionManager.getInstance_2(); + GameLoadingThread.getInstance(); + GameLoadingThread.execute94(); + if (c0035dM216a2 != null) { + try { + c0035dM216a2.sendPacket220(); + } catch (IOException unused) { + runnableC0028baM187b.execute190(); + c0035dM216a2.sendPacket223(); + ConnectionManager.execute217(); + this.f44E = 0; + this.f45F = false; + this.value181 = 25; + execute37(); + } + } + GameLoadingThread.getInstance(); + GameLoadingThread.showScreen95(); + } + } + + /* renamed from: n */ + private void execute58() { + execute38("host"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i3 = 0; i3 < "init bluetooth...".length(); i3++) { + execute68("init bluetooth...".charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + flushGraphics(); + } + + /* renamed from: o */ + private void execute59() { + this.graphics.setColor(255, 255, 255); + this.graphics.fillRect(0, 0, getWidth(), getHeight()); + this.graphics.setColor(0, 0, 0); + this.graphics.drawString("Bluetooth not permitted!", 10, 10, 20); + this.graphics.drawString("Return Main Menu", 10, 150, 20); + this.graphics.drawLine(10, 169, 70, 169); + flushGraphics(); + } + + /* renamed from: p */ + private void execute60() { + this.value181 = 0; + execute37(); + } + + /* renamed from: q */ + private void execute61() { + execute38("client"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i3 = 0; i3 < "searching server...".length(); i3++) { + execute68("searching server...".charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: r */ + private void execute62() { + execute38("client"); + this.graphics.setColor(0, 0, 0); + Vector vector = BluetoothDiscoveryClient.getInstance().list230; + vector.size(); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + String string = new StringBuffer(String.valueOf(vector.size())).append(" server(s) found:").toString(); + int[] iArr = new int[4]; + for (int i3 = 0; i3 < string.length(); i3++) { + execute68(string.charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + if (vector.size() == 0) { + this.f48I = false; + int i4 = 60; + for (int i5 = 0; i5 < f37A.length; i5++) { + String lowerCase = f37A[i5].toLowerCase(); + int i6 = 10; + i4 += i5 * 14; + int[] iArr2 = new int[4]; + for (int i7 = 0; i7 < lowerCase.length(); i7++) { + execute68(lowerCase.charAt(i7), iArr2); + if (iArr2[0] != -1) { + this.graphics.drawRegion(image40, iArr2[0], iArr2[1], iArr2[2], iArr2[3], 0, i6, i4, 20); + i6 += iArr2[2]; + } else { + i6 += 6; + } + } + if (i5 == this.f46G) { + this.graphics.drawImage(image28, 4, i4 + 3, 6); + } + } + } else { + this.f48I = true; + int i8 = 60; + for (int i9 = 0; i9 < vector.size(); i9++) { + String lowerCase2 = ""; + try { + lowerCase2 = ((ServiceRecord) vector.elementAt(i9)).getHostDevice().getFriendlyName(true).toLowerCase(); + } catch (IOException unused) { + } + int i10 = 10; + i8 += i9 * 14; + int[] iArr3 = new int[4]; + for (int i11 = 0; i11 < lowerCase2.length(); i11++) { + execute68(lowerCase2.charAt(i11), iArr3); + if (iArr3[0] != -1) { + this.graphics.drawRegion(image40, iArr3[0], iArr3[1], iArr3[2], iArr3[3], 0, i10, i8, 20); + i10 += iArr3[2]; + } else { + i10 += 6; + } + } + if (i9 == this.f47H) { + this.graphics.drawImage(image28, 4, i8 + 3, 6); + } + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: i */ + private void execute63(int i) { + if (this.f48I) { + int size = BluetoothDiscoveryClient.getInstance().list230.size(); + if (getGameAction(i) == 1) { + if (this.f47H == 0) { + this.f47H = size - 1; + } else { + this.f47H--; + } + } else if (getGameAction(i) == 6) { + if (this.f47H == size - 1) { + this.f47H = 0; + } else { + this.f47H++; + } + } else if (getGameAction(i) == 8) { + this.f46G = 0; + this.f47H = 0; + this.f48I = false; + this.value181 = 23; + BluetoothDiscoveryClient.getInstance().execute269(this.f47H); + } + } else if (i == 56 || getGameAction(i) == 1) { + if (this.f46G == 0) { + this.f46G = f37A.length - 1; + } else { + this.f46G--; + } + } else if (i == 50 || getGameAction(i) == 6) { + if (this.f46G == f37A.length - 1) { + this.f46G = 0; + } else { + this.f46G++; + } + } else if (i == 53 || getGameAction(i) == 8) { + if (this.f46G == 0) { + this.value181 = 21; + BluetoothDiscoveryClient.getInstance().execute267(); + } else { + this.f46G = 0; + this.f47H = 0; + this.f48I = false; + this.value181 = 0; + execute37(); + } + } + execute37(); + } + + /* renamed from: s */ + private void execute64() { + execute38("client"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i3 = 0; i3 < "connecting...".length(); i3++) { + execute68("connecting...".charAt(i3), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i2, 20); + i += iArr[2]; + } else { + i += 6; + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: t */ + private void execute65() { + execute38("client"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode; + int i3 = i2 == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i4 = 0; i4 < "connected.".length(); i4++) { + execute68("connected.".charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i3, 20); + i += iArr[2]; + } else { + i += 6; + } + } + int i5 = 10; + int i6 = i2 == 1 ? 50 : 63; + int[] iArr2 = new int[4]; + for (int i7 = 0; i7 < "ready for starting...".length(); i7++) { + execute68("ready for starting...".charAt(i7), iArr2); + if (iArr2[0] != -1) { + this.graphics.drawRegion(image40, iArr2[0], iArr2[1], iArr2[2], iArr2[3], 0, i5, i6, 20); + i5 += iArr2[2]; + } else { + i5 += 6; + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: u */ + private void execute66() { + execute38("bluetooth"); + int i = 10; + int i2 = PlatformServices.getInstance().uiLayoutMode; + int i3 = i2 == 1 ? 30 : 43; + int[] iArr = new int[4]; + for (int i4 = 0; i4 < "bluetooth is disconnected.".length(); i4++) { + execute68("bluetooth is disconnected.".charAt(i4), iArr); + if (iArr[0] != -1) { + this.graphics.drawRegion(image40, iArr[0], iArr[1], iArr[2], iArr[3], 0, i, i3, 20); + i += iArr[2]; + } else { + i += 6; + } + } + int i5 = 10; + int i6 = i2 == 1 ? 50 : 63; + int[] iArr2 = new int[4]; + for (int i7 = 0; i7 < "press any key to return.".length(); i7++) { + execute68("press any key to return.".charAt(i7), iArr2); + if (iArr2[0] != -1) { + this.graphics.drawRegion(image40, iArr2[0], iArr2[1], iArr2[2], iArr2[3], 0, i5, i6, 20); + i5 += iArr2[2]; + } else { + i5 += 6; + } + } + flushGraphics(); + if (this.midlet.display.getCurrent() != this) { + this.midlet.display.setCurrent(this); + } + } + + /* renamed from: v */ + private void execute67() { + this.value181 = 0; + execute37(); + } + + /* renamed from: a */ + public static void execute68(char c, int[] iArr) { + iArr[0] = -1; + iArr[1] = -1; + iArr[2] = -1; + iArr[3] = -1; + if (c >= 'a' && c <= 'z') { + iArr[0] = 0 + ((c - 97) * 6); + iArr[1] = 0; + iArr[2] = 6; + iArr[3] = 6; + } + if (c >= '0' && c <= '9') { + iArr[0] = 156 + ((c - 48) * 6); + iArr[1] = 0; + iArr[2] = 6; + iArr[3] = 6; + return; + } + switch (c) { + case '!': + iArr[0] = 225; + iArr[1] = 0; + iArr[2] = 3; + iArr[3] = 6; + break; + case '#': + iArr[0] = 264; + iArr[1] = 0; + iArr[2] = 7; + iArr[3] = 6; + break; + case '$': + iArr[0] = 257; + iArr[1] = 0; + iArr[2] = 7; + iArr[3] = 6; + break; + case '\'': + iArr[0] = 222; + iArr[1] = 0; + iArr[2] = 3; + iArr[3] = 6; + break; + case '(': + iArr[0] = 236; + iArr[1] = 0; + iArr[2] = 4; + iArr[3] = 6; + break; + case ')': + iArr[0] = 240; + iArr[1] = 0; + iArr[2] = 4; + iArr[3] = 6; + break; + case '*': + iArr[0] = 286; + iArr[1] = 0; + iArr[2] = 7; + iArr[3] = 6; + break; + case ',': + iArr[0] = 219; + iArr[1] = 0; + iArr[2] = 3; + iArr[3] = 6; + break; + case '-': + iArr[0] = 244; + iArr[1] = 0; + iArr[2] = 6; + iArr[3] = 6; + break; + case '.': + iArr[0] = 216; + iArr[1] = 0; + iArr[2] = 3; + iArr[3] = 6; + break; + case ':': + iArr[0] = 232; + iArr[1] = 0; + iArr[2] = 4; + iArr[3] = 6; + break; + case ';': + iArr[0] = 228; + iArr[1] = 0; + iArr[2] = 4; + iArr[3] = 6; + break; + case '?': + iArr[0] = 250; + iArr[1] = 0; + iArr[2] = 7; + iArr[3] = 6; + break; + case '@': + iArr[0] = 271; + iArr[1] = 0; + iArr[2] = 7; + iArr[3] = 6; + break; + case '^': + iArr[0] = 278; + iArr[1] = 0; + iArr[2] = 8; + iArr[3] = 6; + break; + } + } + + /* renamed from: b */ + public static void execute69(char c, int[] iArr) { + iArr[0] = -1; + iArr[1] = -1; + iArr[2] = -1; + iArr[3] = -1; + if (c < 'a' || c > 'z') { + return; + } + iArr[0] = (c - 97) * 8; + iArr[1] = 0; + iArr[2] = 8; + iArr[3] = 8; + } + + /* renamed from: c */ + public static void loadImages70() { + Image imageCreateImage; + try { + image27 = Image.createImage("/res/image2d/title_s.png"); + image26 = Image.createImage("/res/image2d/title.png"); + image28 = Image.createImage("/res/image2d/arrow_s.png"); + image40 = Image.createImage("/res/image2d/text.png"); + image41 = Image.createImage("/res/image2d/text_orange.png"); + imageCreateImage = Image.createImage("/res/image2d/text_b.png"); + image39 = imageCreateImage; + } catch (Exception e) { + imageCreateImage.printStackTrace(); + } + } + + /* renamed from: d */ + public static void execute71() { + image26 = null; + image27 = null; + image28 = null; + image40 = null; + image41 = null; + image39 = null; + } +} diff --git a/p000/MainUiCanvasBase.java b/p000/MainUiCanvasBase.java new file mode 100644 index 0000000..62dd5db --- /dev/null +++ b/p000/MainUiCanvasBase.java @@ -0,0 +1,118 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import javax.microedition.lcdui.Graphics; +import javax.microedition.lcdui.game.GameCanvas; + +/* renamed from: f */ +/* loaded from: microcounterstrike.jar:f.class */ +public abstract class MainUiCanvasBase extends GameCanvas { + + /* renamed from: m */ + private static MainUiCanvasBase instance; + + /* renamed from: a */ + public GameAppMidlet midlet; + + /* renamed from: b */ + public Graphics graphics; + + /* renamed from: c */ + public int sessionType; + + /* renamed from: d */ + public int value181; + + /* renamed from: e */ + public int value182; + + /* renamed from: f */ + public int value183; + + /* renamed from: g */ + public int value184; + + /* renamed from: h */ + public int value185; + + /* renamed from: i */ + public int value186; + + /* renamed from: j */ + public int value187; + + /* renamed from: k */ + public boolean soundEnabled; + + /* renamed from: l */ + public boolean soundEnabledPending; + + public MainUiCanvasBase() { + super(false); + this.midlet = GameAppMidlet.getInstance(); + this.graphics = null; + this.value182 = 0; + this.value183 = 1; + this.value187 = 0; + this.soundEnabled = false; + this.soundEnabledPending = this.soundEnabled; + setFullScreenMode(true); + this.graphics = getGraphics(); + if (getWidth() < 120) { + PlatformServices.getInstance().uiLayoutMode = 1; + } else { + PlatformServices.getInstance().uiLayoutMode = 0; + } + this.value181 = 0; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [f] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [f] */ + /* renamed from: a */ + public static MainUiCanvasBase getInstance() { + ?? r0 = instance; + if (r0 == 0) { + try { + r0 = (MainUiCanvasBase) PlatformServices.getInstance().getMainMenuCanvasClass().newInstance(); + instance = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return instance; + } + + /* renamed from: b */ + public abstract void execute37(); + + /* renamed from: a */ + public abstract void showScreen53(String str); + + public abstract void keyPressed(int i); + + public void sizeChanged(int i, int i2) { + this.graphics = getGraphics(); + execute37(); + } + + /* renamed from: c */ + public static void loadMenuResources() { + PlatformServices.getInstance().loadMainMenuResources(); + } + + /* renamed from: d */ + public static void unloadMenuResources() { + PlatformServices.getInstance().unloadMainMenuResources(); + } + + /* renamed from: a */ + public final void setSoundEnabled(boolean z) { + this.soundEnabled = z; + this.soundEnabledPending = z; + } +} diff --git a/p000/MapInfo.java b/p000/MapInfo.java new file mode 100644 index 0000000..2455a2b --- /dev/null +++ b/p000/MapInfo.java @@ -0,0 +1,21 @@ +package p000; + +/* renamed from: ai */ +/* loaded from: microcounterstrike.jar:ai.class */ +public final class MapInfo { + + /* renamed from: a */ + public String displayName; + + /* renamed from: b */ + public String resourcePath; + + /* renamed from: c */ + public boolean hasRoundTimer; + + /* renamed from: d */ + public float[] spawnPoints; + + /* renamed from: e */ + public int[] collisionObjectIds; +} diff --git a/p000/MapManager.java b/p000/MapManager.java new file mode 100644 index 0000000..f39e045 --- /dev/null +++ b/p000/MapManager.java @@ -0,0 +1,238 @@ +package p000; + +import java.util.Vector; +import javax.microedition.m3g.Appearance; +import javax.microedition.m3g.Background; +import javax.microedition.m3g.CompositingMode; +import javax.microedition.m3g.Group; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.Light; +import javax.microedition.m3g.Loader; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.Sprite3D; +import javax.microedition.m3g.World; + +/* renamed from: aa */ +/* loaded from: microcounterstrike.jar:aa.class */ +public final class MapManager { + + /* renamed from: f */ + private static MapManager instance; + + /* renamed from: b */ + public World world; + + /* renamed from: c */ + public int currentMapIndex; + + /* renamed from: d */ + public float[] worldBoundsXZ; + + /* renamed from: e */ + public Vector[][] collisionCells; + + /* renamed from: a */ + public Vector maps = new Vector(); + + /* renamed from: g */ + private Vector decorations = null; + + static { + PlatformServices.getInstance().registerBuiltInMaps(); + } + + private MapManager() { + } + + /* renamed from: a */ + public static MapManager getInstance() { + if (instance == null) { + instance = new MapManager(); + } + return instance; + } + + /* renamed from: b */ + public final World loadCurrentMap() { + try { + World[] worldArrLoad = Loader.load(getCurrentMapInfo().resourcePath); + int i = 0; + while (true) { + if (i >= worldArrLoad.length) { + break; + } + if (worldArrLoad[i] instanceof World) { + this.world = worldArrLoad[i]; + break; + } + i++; + } + applyMapLighting(this.currentMapIndex); + addDirectionalLight(); + buildCollisionGrid(); + } catch (Exception e) { + System.out.println("Load map error!"); + e.printStackTrace(); + } + return this.world; + } + + /* renamed from: a */ + private void applyMapLighting(int i) { + if (i != 5) { + addMoonSprite(); + } + switch (i) { + case 1: + createTrees(); + break; + } + } + + /* renamed from: f */ + private void addMoonSprite() { + try { + Image2D image2DM129a = ResourceLoader.loadM3G129("/res/map/moon.png"); + Appearance appearance = new Appearance(); + CompositingMode compositingMode = new CompositingMode(); + compositingMode.setBlending(68); + appearance.setCompositingMode(compositingMode); + Sprite3D sprite3D = new Sprite3D(false, image2DM129a, appearance); + this.world.addChild(sprite3D); + sprite3D.setTranslation(0.0f, 50.0f, 0.0f); + } catch (Exception e) { + System.out.println(new StringBuffer("createMoon error!").append(e).toString()); + e.printStackTrace(); + } + } + + /* renamed from: g */ + private void createTrees() { + this.decorations = new Vector(); + Image2D image2DM132b = ResourceLoader.loadImages132("/res/map/tree.png"); + BillboardSprite c0013am = new BillboardSprite(image2DM132b, CameraManager.getInstance().getCamera121("MAIN"), 38.8f, 8.0f, 59.1f, 16.0f); + this.decorations.addElement(c0013am); + this.world.addChild(c0013am.mesh75); + BillboardSprite c0013am2 = new BillboardSprite(image2DM132b, CameraManager.getInstance().getCamera121("MAIN"), 31.9f, 8.0f, 90.2f, 16.0f); + this.decorations.addElement(c0013am2); + this.world.addChild(c0013am2.mesh75); + BillboardSprite c0013am3 = new BillboardSprite(image2DM132b, CameraManager.getInstance().getCamera121("MAIN"), -57.9f, 8.0f, -51.7f, 16.0f); + this.decorations.addElement(c0013am3); + this.world.addChild(c0013am3.mesh75); + } + + /* renamed from: c */ + public final void updateDecorations() { + if (this.decorations == null) { + return; + } + for (int i = 0; i < this.decorations.size(); i++) { + ((BillboardSprite) this.decorations.elementAt(i)).execute106(); + } + } + + /* renamed from: h */ + private void addDirectionalLight() { + Light light = new Light(); + light.setMode(128); + light.setIntensity(3.0f); + this.world.addChild(light); + } + + /* renamed from: i */ + private void buildCollisionGrid() { + int[] iArr = getCurrentMapInfo().collisionObjectIds; + this.worldBoundsXZ = new float[4]; + if (iArr == null) { + this.worldBoundsXZ[0] = -400.0f; + this.worldBoundsXZ[1] = -400.0f; + this.worldBoundsXZ[2] = 400.0f; + this.worldBoundsXZ[3] = 400.0f; + this.collisionCells = new Vector[(int) Math.ceil((this.worldBoundsXZ[3] - this.worldBoundsXZ[1]) / 20.0f)][(int) Math.ceil((this.worldBoundsXZ[2] - this.worldBoundsXZ[0]) / 20.0f)]; + return; + } + this.worldBoundsXZ[0] = Float.MAX_VALUE; + this.worldBoundsXZ[1] = Float.MAX_VALUE; + this.worldBoundsXZ[2] = -3.4028235E38f; + this.worldBoundsXZ[3] = -3.4028235E38f; + AxisAlignedBoundingBox[] c0025ayArr = new AxisAlignedBoundingBox[iArr.length]; + for (int i = 0; i < iArr.length; i++) { + Mesh meshFind = this.world.find(iArr[i]); + AxisAlignedBoundingBox c0025ay = new AxisAlignedBoundingBox(ResourceLoader.getFloatArray134(meshFind, (Group) this.world), meshFind); + c0025ayArr[i] = c0025ay; + float[] fArr = c0025ay.value109; + float[] fArr2 = c0025ay.value110; + if (fArr[0] < this.worldBoundsXZ[0]) { + this.worldBoundsXZ[0] = fArr[0]; + } + if (fArr[2] < this.worldBoundsXZ[1]) { + this.worldBoundsXZ[1] = fArr[2]; + } + if (fArr2[0] > this.worldBoundsXZ[2]) { + this.worldBoundsXZ[2] = fArr2[0]; + } + if (fArr2[2] > this.worldBoundsXZ[3]) { + this.worldBoundsXZ[3] = fArr2[2]; + } + } + float[] fArr3 = this.worldBoundsXZ; + fArr3[0] = fArr3[0] - 2.0f; + float[] fArr4 = this.worldBoundsXZ; + fArr4[1] = fArr4[1] - 2.0f; + float[] fArr5 = this.worldBoundsXZ; + fArr5[2] = fArr5[2] + 2.0f; + float[] fArr6 = this.worldBoundsXZ; + fArr6[3] = fArr6[3] + 2.0f; + float f = this.worldBoundsXZ[2] - this.worldBoundsXZ[0]; + this.collisionCells = new Vector[(int) Math.ceil((this.worldBoundsXZ[3] - this.worldBoundsXZ[1]) / 20.0f)][(int) Math.ceil(f / 20.0f)]; + for (AxisAlignedBoundingBox c0025ay2 : c0025ayArr) { + float f2 = c0025ay2.value109[0]; + float f3 = c0025ay2.value109[2]; + float f4 = c0025ay2.value110[0]; + float f5 = c0025ay2.value110[2]; + float f6 = (f3 - this.worldBoundsXZ[1]) / 20.0f; + int iFloor = f6 < 1.0f ? 0 : (int) Math.floor(f6); + float f7 = (f2 - this.worldBoundsXZ[0]) / 20.0f; + int iFloor2 = f7 < 1.0f ? 0 : (int) Math.floor(f7); + float f8 = (f5 - this.worldBoundsXZ[1]) / 20.0f; + int iFloor3 = f8 < 1.0f ? 0 : (int) Math.floor(f8); + float f9 = (f4 - this.worldBoundsXZ[0]) / 20.0f; + int iFloor4 = f9 < 1.0f ? 0 : (int) Math.floor(f9); + for (int i2 = iFloor; i2 <= iFloor3; i2++) { + for (int i3 = iFloor2; i3 <= iFloor4; i3++) { + if (this.collisionCells[i2][i3] == null) { + this.collisionCells[i2][i3] = new Vector(); + } + this.collisionCells[i2][i3].addElement(c0025ay2); + } + } + } + } + + /* renamed from: d */ + public final void unloadMap() { + this.world = null; + this.worldBoundsXZ = null; + this.collisionCells = null; + this.decorations = null; + } + + /* renamed from: a */ + public final void setBackgroundCrop(int i, int i2) { + Background background = this.world.getBackground(); + if (background != null) { + background.setImageMode(33, 32); + background.setCrop(0, (background.getImage().getHeight() - i2) / 2, i, i2); + } + } + + /* renamed from: a */ + public final void addMap(MapInfo c0009ai) { + this.maps.addElement(c0009ai); + } + + /* renamed from: e */ + public final MapInfo getCurrentMapInfo() { + return (MapInfo) this.maps.elementAt(this.currentMapIndex); + } +} diff --git a/p000/MuzzleFlashManager.java b/p000/MuzzleFlashManager.java new file mode 100644 index 0000000..0ca7bae --- /dev/null +++ b/p000/MuzzleFlashManager.java @@ -0,0 +1,89 @@ +package p000; + +import java.util.Vector; +import javax.microedition.lcdui.Image; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.Image2D; + +/* renamed from: bf */ +/* loaded from: microcounterstrike.jar:bf.class */ +public final class MuzzleFlashManager { + + /* renamed from: e */ + private static MuzzleFlashManager muzzleFlashManager154; + + /* renamed from: a */ + public static Image2D[] texture155; + + /* renamed from: b */ + public static Image[] image156; + + /* renamed from: c */ + public static Image2D[] texture157; + + /* renamed from: d */ + public static Image[] image158; + + /* renamed from: f */ + private Vector list159 = new Vector(); + + private MuzzleFlashManager() { + } + + /* renamed from: a */ + public static MuzzleFlashManager getInstance() { + if (muzzleFlashManager154 == null) { + muzzleFlashManager154 = new MuzzleFlashManager(); + } + return muzzleFlashManager154; + } + + /* renamed from: b */ + public static void execute208() { + image156 = new Image[3]; + texture155 = ResourceLoader.loadImages131("/res/image2d/muzzleflash_r.png", 3, 32, image156); + image158 = new Image[1]; + texture157 = ResourceLoader.loadImages131("/res/image2d/muzzleflash_p.png", 1, 32, image158); + } + + /* renamed from: a */ + public final AnimatedBillboardSprite getAnimatedBillboardSprite209(Camera camera, int i) { + if (this.list159 == null) { + this.list159 = new Vector(); + } + Image2D[] image2DArr = (Image2D[]) null; + if (i == 1) { + image2DArr = texture155; + } else if (i == 2) { + image2DArr = texture157; + } + AnimatedBillboardSprite c0027b = new AnimatedBillboardSprite(image2DArr, camera, 3.0f); + c0027b.mesh121.setPickingEnable(false); + this.list159.addElement(c0027b); + return c0027b; + } + + /* renamed from: c */ + public final void execute210() { + if (this.list159 == null) { + return; + } + for (int i = 0; i < this.list159.size(); i++) { + Object objElementAt = this.list159.elementAt(i); + if (objElementAt != null) { + ((AnimatedBillboardSprite) objElementAt).execute184(); + } + } + } + + /* renamed from: d */ + public final void execute211() { + this.list159 = null; + } + + /* renamed from: e */ + public static void execute212() { + texture155 = null; + texture157 = null; + } +} diff --git a/p000/NetworkPlayerEntity.java b/p000/NetworkPlayerEntity.java new file mode 100644 index 0000000..aba74a1 --- /dev/null +++ b/p000/NetworkPlayerEntity.java @@ -0,0 +1,221 @@ +package p000; + +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.World; + +/* renamed from: n */ +/* loaded from: microcounterstrike.jar:n.class */ +public class NetworkPlayerEntity extends PlayerEntityBase { + + /* renamed from: a */ + public float[] value216; + + /* renamed from: r */ + private Transform transform217; + + /* renamed from: b */ + public Transform transform218; + + /* renamed from: c */ + public Transform transform219; + + /* renamed from: s */ + private float value220; + + /* renamed from: d */ + public int value221; + + /* renamed from: e */ + public int value222; + + /* renamed from: f */ + public int value223; + + public NetworkPlayerEntity(int i, String str, int i2) { + super(i, str, i2); + this.transform217 = new Transform(); + this.transform218 = new Transform(); + this.transform219 = new Transform(); + this.value220 = 0.0f; + this.value222 = -1; + this.value223 = 0; + this.playerModelBase261 = new PlayerModel(this); + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public void addToWorld(World world) { + this.playerModelBase261.loadM3G0(world).setUserObject(this); + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public void removeFromWorld() { + super.removeFromWorld(); + this.transform217 = null; + this.transform218 = null; + this.transform219 = null; + this.value216 = null; + } + + @Override // p000.PlayerEntityBase + /* renamed from: b */ + public void respawn() { + super.respawn(); + this.value221 = (PlayerModel.CONST_VALUE251[1][1] - PlayerModel.CONST_VALUE251[1][0]) - 1; + this.transform217.setIdentity(); + this.transform218.setIdentity(); + this.transform219.setIdentity(); + this.value222 = -1; + execute245(); + } + + @Override // p000.PlayerEntityBase + /* renamed from: c */ + public final void execute245() { + PlayerModel c0051t = (PlayerModel) this.playerModelBase261; + c0051t.group239.setTransform(this.transform217); + c0051t.group240.setTransform(this.transform218); + c0051t.group241.setTransform(this.transform219); + boolean z = false; + if (this.value222 == 0 || this.value222 == -1) { + z = true; + } else { + float[] fArrM289i = getFloatArray289(); + float[] fArrM289i2 = PlayerManager.getInstance().localPlayer.getFloatArray289(); + if (((fArrM289i2[0] - fArrM289i[0]) * (fArrM289i2[0] - fArrM289i[0])) + ((fArrM289i2[2] - fArrM289i[2]) * (fArrM289i2[2] - fArrM289i[2])) < 3600.0f) { + z = true; + } + } + if (z) { + this.playerModelBase261.node234.animate(this.value221 * 50); + } + } + + @Override // p000.PlayerEntityBase + /* renamed from: d */ + public final float getFloat246() { + return 1.0f; + } + + /* renamed from: a */ + public final float[] getFloatArray247(float[] fArr) { + float[] fArr2 = new float[3]; + if (getAxisAlignedBoundingBox288(fArr) == null) { + fArr2[0] = fArr[0]; + fArr2[1] = fArr[1]; + fArr2[2] = fArr[2]; + } + return fArr2; + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public final float getFloat248(float f) { + this.value264 += f; + if (this.value264 > 75.0f) { + this.value264 = 75.0f; + return 0.0f; + } + this.transform217.postRotate(f, PlayerModel.value248[0], PlayerModel.value248[1], PlayerModel.value248[2]); + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: b */ + public final float getFloat249(float f) { + this.value264 -= f; + if (this.value264 < -75.0f) { + this.value264 = -75.0f; + return 0.0f; + } + this.transform217.postRotate(-f, PlayerModel.value248[0], PlayerModel.value248[1], PlayerModel.value248[2]); + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: c */ + public final float getFloat250(float f) { + this.value265 += f; + this.transform218.postRotate(f, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value220 += f; + if (this.value220 >= 45.0f) { + execute254(); + } + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: d */ + public final float getFloat251(float f) { + this.value265 -= f; + this.transform218.postRotate(-f, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value220 -= f; + if (this.value220 <= -45.0f) { + execute254(); + } + return f; + } + + /* renamed from: a */ + public final void execute252(int i, float[] fArr) { + this.value216 = fArr; + if (i == 1 || i == 2) { + execute254(); + } else { + execute255(); + } + execute256(i); + execute282(fArr); + } + + /* renamed from: a_ */ + public final void m253a_() { + int i = PlayerModel.CONST_VALUE251[1][1]; + this.playerModelBase261.node234.translate(this.value216[0] / i, this.value216[1] / i, this.value216[2] / i); + } + + /* renamed from: j */ + private void execute254() { + this.transform219.postRotate(this.value220, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value220 = 0.0f; + } + + /* renamed from: k */ + private void execute255() { + float f; + if (this.value220 > 0.0f) { + f = 60.0f - this.value220; + this.value220 = 60.0f; + } else { + f = (-60.0f) - this.value220; + this.value220 = -60.0f; + } + this.transform219.postRotate(-f, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + } + + /* renamed from: a */ + public final void execute256(int i) { + if (i == 0) { + this.transform217.setIdentity(); + this.transform218.setIdentity(); + this.transform219.setIdentity(); + } + this.value222 = i; + this.value223 = 1; + } + + /* renamed from: f */ + public final void execute257() { + if (getBoolean258()) { + return; + } + this.value221 = PlayerModel.CONST_VALUE251[this.value222][0] + (this.value223 - 1); + this.value223++; + } + + /* renamed from: g */ + public final boolean getBoolean258() { + return this.value222 == -1 || this.value223 > PlayerModel.CONST_VALUE251[this.value222][1]; + } +} diff --git a/p000/NetworkStateCache.java b/p000/NetworkStateCache.java new file mode 100644 index 0000000..4c169e3 --- /dev/null +++ b/p000/NetworkStateCache.java @@ -0,0 +1,21 @@ +package p000; + +/* renamed from: c */ +/* loaded from: microcounterstrike.jar:c.class */ +public final class NetworkStateCache { + + /* renamed from: a */ + public float[] value160 = new float[3]; + + /* renamed from: b */ + public int value161 = 100; + + /* renamed from: c */ + public float[] value162 = new float[9]; + + /* renamed from: d */ + public float[] value163 = new float[9]; + + /* renamed from: e */ + public int value164 = -1; +} diff --git a/p000/OverlayMenuBase.java b/p000/OverlayMenuBase.java new file mode 100644 index 0000000..aa27f11 --- /dev/null +++ b/p000/OverlayMenuBase.java @@ -0,0 +1,64 @@ +package p000; + +import javax.microedition.lcdui.Graphics; + +/* renamed from: g */ +/* loaded from: microcounterstrike.jar:g.class */ +public abstract class OverlayMenuBase { + + /* renamed from: c */ + private static OverlayMenuBase overlayMenuBase190; + + /* renamed from: a */ + public int value191; + + /* renamed from: b */ + public boolean flag192 = false; + + /* renamed from: a */ + public static void execute231() { + PlatformServices.getInstance().loadInGameMenuResources(); + } + + /* renamed from: b */ + public static void execute232() { + PlatformServices.getInstance().unloadInGameMenuResources(); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v0, types: [g] */ + /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v6, types: [g] */ + /* renamed from: c */ + public static OverlayMenuBase getInstance() { + ?? r0 = overlayMenuBase190; + if (r0 == 0) { + try { + r0 = (OverlayMenuBase) PlatformServices.getInstance().getInGameMenuOverlayClass().newInstance(); + overlayMenuBase190 = r0; + } catch (IllegalAccessException e) { + r0.printStackTrace(); + } catch (InstantiationException e2) { + r0.printStackTrace(); + } + } + return overlayMenuBase190; + } + + /* renamed from: a */ + public abstract void execute23(Graphics graphics, GameRenderCanvas c0002ab); + + /* renamed from: a */ + public abstract void execute29(int i, int i2); + + /* renamed from: d */ + public void execute34() { + this.flag192 = true; + } + + /* renamed from: e */ + public void execute35() { + this.flag192 = false; + } +} diff --git a/p000/ParticleEffectManager.java b/p000/ParticleEffectManager.java new file mode 100644 index 0000000..2e17501 --- /dev/null +++ b/p000/ParticleEffectManager.java @@ -0,0 +1,219 @@ +package p000; + +import java.util.Vector; +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.World; + +/* renamed from: v */ +/* loaded from: microcounterstrike.jar:v.class */ +public final class ParticleEffectManager { + + /* renamed from: a */ + private static ParticleEffectManager particleEffectManager267; + + /* renamed from: b */ + private static Image2D[] texture268; + + /* renamed from: c */ + private static Image2D[] texture269; + + /* renamed from: d */ + private static Image2D[] texture270; + + /* renamed from: e */ + private static Image2D[] texture271; + + /* renamed from: f */ + private Vector list272; + + /* renamed from: g */ + private Vector list273; + + /* renamed from: h */ + private Vector list274; + + /* renamed from: i */ + private Vector list275; + + private ParticleEffectManager() { + } + + /* renamed from: a */ + public static ParticleEffectManager getInstance() { + if (particleEffectManager267 == null) { + particleEffectManager267 = new ParticleEffectManager(); + } + return particleEffectManager267; + } + + /* renamed from: b */ + public static void execute291() { + texture268 = ResourceLoader.loadImages130("/res/image2d/bloodspray.png", 4, 32); + if (PlatformServices.getInstance().getBoolean142()) { + texture269 = ResourceLoader.loadImages130("/res/image2d/smokepuff.png", 4, 32); + } + if (PlatformServices.getInstance().getBoolean143()) { + texture270 = ResourceLoader.loadImages130("/res/image2d/wallsplash.png", 4, 32); + } + texture271 = ResourceLoader.loadImages130("/res/image2d/explosion.png", 6, 64); + } + + /* renamed from: a */ + public final void execute292(int i, RayIntersection rayIntersection, World world, Camera camera) { + Vector vector = null; + Image2D[] image2DArr = (Image2D[]) null; + float f = 1.0f; + if (this.list272 == null) { + this.list272 = new Vector(); + } + if (this.list273 == null) { + this.list273 = new Vector(); + } + if (this.list274 == null) { + this.list274 = new Vector(); + } + if (i == 1) { + vector = this.list272; + image2DArr = texture268; + f = 16.0f; + } else if (i == 2) { + vector = this.list273; + image2DArr = texture269; + f = 6.0f; + } else if (i == 3) { + vector = this.list274; + image2DArr = texture270; + f = 16.0f; + } + AnimatedBillboardSprite c0027b = null; + int i2 = 0; + while (true) { + if (i2 >= vector.size()) { + break; + } + AnimatedBillboardSprite c0027b2 = (AnimatedBillboardSprite) vector.elementAt(i2); + if (!c0027b2.flag126) { + c0027b = c0027b2; + break; + } + i2++; + } + if (c0027b == null) { + AnimatedBillboardSprite c0027b3 = null; + if (vector.size() > 0) { + c0027b3 = (AnimatedBillboardSprite) vector.elementAt(0); + } + c0027b = c0027b3 != null ? new AnimatedBillboardSprite(c0027b3.mesh121, c0027b3.texture123, camera) : new AnimatedBillboardSprite(image2DArr, camera, f); + world.addChild(c0027b.mesh121); + vector.addElement(c0027b); + } + c0027b.execute183(true); + float f2 = 0.0f; + float f3 = 0.0f; + float f4 = 0.0f; + if (rayIntersection != null) { + float distance = rayIntersection.getDistance(); + float[] fArr = new float[6]; + rayIntersection.getRay(fArr); + f2 = fArr[0] + (fArr[3] * distance); + f3 = fArr[1] + (fArr[4] * distance); + f4 = fArr[2] + (fArr[5] * distance); + } + c0027b.execute182(f2, f3, f4); + if (i == 2) { + execute293(c0027b, rayIntersection, world); + } + } + + /* renamed from: a */ + private static void execute293(AnimatedBillboardSprite c0027b, RayIntersection rayIntersection, World world) { + float normalX = rayIntersection.getNormalX(); + float normalY = rayIntersection.getNormalY(); + float normalZ = rayIntersection.getNormalZ(); + Node intersected = rayIntersection.getIntersected(); + Transform transform = new Transform(); + intersected.getTransformTo(world, transform); + float[] fArr = {normalX, normalY, normalZ, 0.0f}; + transform.transform(fArr); + float[] fArr2 = {fArr[0], fArr[1], fArr[2]}; + float[] fArr3 = new float[6]; + rayIntersection.getRay(fArr3); + if (VectorMath.getFloat259(fArr2, new float[]{fArr3[3], fArr3[4], fArr3[5]}) > 0.0f) { + fArr2[0] = -fArr2[0]; + fArr2[1] = -fArr2[1]; + fArr2[2] = -fArr2[2]; + } + float fM261a = 0.2f / VectorMath.getFloat261(fArr2); + fArr2[0] = fArr2[0] * fM261a; + fArr2[1] = (fArr2[1] * fM261a) + 0.08f; + fArr2[2] = fArr2[2] * fM261a; + c0027b.execute185(fArr2); + } + + /* renamed from: a */ + public final void execute294(float[] fArr, World world, Camera camera) { + if (this.list275 == null) { + this.list275 = new Vector(); + } + AnimatedBillboardSprite c0027b = null; + int i = 0; + while (true) { + if (i >= this.list275.size()) { + break; + } + AnimatedBillboardSprite c0027b2 = (AnimatedBillboardSprite) this.list275.elementAt(i); + if (!c0027b2.flag126) { + c0027b = c0027b2; + break; + } + i++; + } + if (c0027b == null) { + c0027b = new AnimatedBillboardSprite(texture271, camera, 32.0f); + world.addChild(c0027b.mesh121); + this.list275.addElement(c0027b); + } + c0027b.execute183(true); + c0027b.execute182(fArr[0], fArr[1], fArr[2]); + } + + /* renamed from: c */ + public final void execute295() { + execute296(this.list272); + execute296(this.list273); + execute296(this.list274); + execute296(this.list275); + } + + /* renamed from: a */ + private static void execute296(Vector vector) { + if (vector != null) { + for (int i = 0; i < vector.size(); i++) { + Object objElementAt = vector.elementAt(i); + if (objElementAt != null) { + ((AnimatedBillboardSprite) objElementAt).execute184(); + } + } + } + } + + /* renamed from: d */ + public final void execute297() { + this.list272 = null; + this.list273 = null; + this.list274 = null; + this.list275 = null; + } + + /* renamed from: e */ + public static void execute298() { + texture268 = null; + texture269 = null; + texture270 = null; + texture271 = null; + } +} diff --git a/p000/PlatformServices.java b/p000/PlatformServices.java new file mode 100644 index 0000000..a613c56 --- /dev/null +++ b/p000/PlatformServices.java @@ -0,0 +1,119 @@ +package p000; + +/* renamed from: l */ +/* loaded from: microcounterstrike.jar:l.class */ +public abstract class PlatformServices { + + /* renamed from: c */ + private static PlatformServices instance; + + /* renamed from: a */ + public int uiLayoutMode = 0; + + /* renamed from: b */ + public static Class implClass; + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r1v5, types: [java.lang.Throwable] */ + /* renamed from: a */ + public static PlatformServices getInstance() throws ClassNotFoundException { + if (instance == null) { + Throwable th = null; + Class cls = null; + try { + try { + Class cls2 = implClass; + if (cls2 == null) { + try { + cls2 = Class.forName("p000.DefaultPlatformServices"); + implClass = cls2; + } catch (ClassNotFoundException unused) { + throw new NoClassDefFoundError(cls2.getMessage()); + } + } + cls = cls2; + } catch (Exception e) { + th.printStackTrace(); + } + instance = (PlatformServices) cls.newInstance(); + } catch (IllegalAccessException e2) { + th.printStackTrace(); + } catch (InstantiationException e3) { + th.printStackTrace(); + } + } + return instance; + } + + /* renamed from: b */ + public abstract boolean getBoolean141(); + + /* renamed from: c */ + public abstract boolean getBoolean142(); + + /* renamed from: d */ + public abstract boolean getBoolean143(); + + /* renamed from: e */ + public abstract Class getGameplayCanvasClass(); + + /* renamed from: f */ + public abstract Class getGameModeClass(); + + /* renamed from: g */ + public abstract Class getMainMenuCanvasClass(); + + /* renamed from: h */ + public abstract Class getHudRendererClass(); + + /* renamed from: i */ + public abstract Class getInGameMenuOverlayClass(); + + /* renamed from: j */ + public abstract Class getPlayerInputControllerClass(); + + /* renamed from: k */ + public abstract Class getBotAiControllerClass(); + + /* renamed from: l */ + public abstract Class getGameplayKeyHandlerClass(); + + /* renamed from: m */ + public abstract int getPreRoundSeconds(); + + /* renamed from: n */ + public abstract int getRoundEndSeconds(); + + /* renamed from: o */ + public abstract boolean getBoolean152(); + + /* renamed from: p */ + public abstract boolean getBoolean153(); + + /* renamed from: q */ + public abstract void loadMainMenuResources(); + + /* renamed from: r */ + public abstract void loadHudResources(); + + /* renamed from: s */ + public abstract void loadInGameMenuResources(); + + /* renamed from: t */ + public abstract void unloadMainMenuResources(); + + /* renamed from: u */ + public abstract void unloadHudResources(); + + /* renamed from: v */ + public abstract void unloadInGameMenuResources(); + + /* renamed from: w */ + public abstract void registerBuiltInMaps(); + + /* renamed from: a */ + public abstract void loadWeaponDefinitions(int i); + + /* renamed from: x */ + public abstract void initCameras(); +} diff --git a/p000/PlayerEntityBase.java b/p000/PlayerEntityBase.java new file mode 100644 index 0000000..1f89212 --- /dev/null +++ b/p000/PlayerEntityBase.java @@ -0,0 +1,327 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.Vector; +import javax.microedition.m3g.World; + +/* renamed from: u */ +/* loaded from: microcounterstrike.jar:u.class */ +public abstract class PlayerEntityBase { + + /* renamed from: g */ + public int value255; + + /* renamed from: h */ + public String text256; + + /* renamed from: i */ + public int value257; + + /* renamed from: j */ + public static float value258 = 0.5f; + + /* renamed from: k */ + public static float value259 = 8.0f; + + /* renamed from: m */ + public PlayerModelBase playerModelBase261; + + /* renamed from: l */ + public int value260 = 0; + + /* renamed from: n */ + public SphereCollider sphereCollider262 = new SphereCollider(); + + /* renamed from: a */ + private SphereCollider sphereCollider263 = new SphereCollider(new float[3], 0.0f); + + /* renamed from: o */ + public float value264 = 0.0f; + + /* renamed from: p */ + public float value265 = 0.0f; + + /* renamed from: q */ + public boolean flag266 = true; + + public PlayerEntityBase(int i, String str, int i2) { + this.value255 = i; + this.text256 = str; + this.value257 = i2; + } + + /* renamed from: a */ + public abstract void addToWorld(World world); + + /* renamed from: a */ + public void removeFromWorld() { + this.playerModelBase261.execute271(); + this.playerModelBase261 = null; + this.sphereCollider262 = null; + this.sphereCollider263 = null; + } + + /* renamed from: d */ + public abstract float getFloat246(); + + /* renamed from: a */ + public abstract float getFloat248(float f); + + /* renamed from: b */ + public abstract float getFloat249(float f); + + /* renamed from: c */ + public abstract float getFloat250(float f); + + /* renamed from: d */ + public abstract float getFloat251(float f); + + /* renamed from: c */ + public abstract void execute245(); + + /* renamed from: b */ + public void respawn() { + this.value264 = 0.0f; + this.value265 = 0.0f; + float[] fArr = MapManager.getInstance().getCurrentMapInfo().spawnPoints; + switch (GameSessionLoop.getInstance().sessionType) { + case 0: + int i = (this.value255 - 1) * 3; + this.playerModelBase261.node234.setTranslation(fArr[i], fArr[i + 1], fArr[i + 2]); + break; + case 1: + int i2 = (this.value255 - 1) * 3; + this.playerModelBase261.node234.setTranslation(fArr[i2], fArr[i2 + 1], fArr[i2 + 2]); + break; + case 2: + if (this.value255 != 1) { + if (this.value255 == 2) { + this.playerModelBase261.node234.setTranslation(fArr[0], fArr[4], fArr[2]); + break; + } + } else { + this.playerModelBase261.node234.setTranslation(fArr[3], fArr[1], fArr[5]); + break; + } + break; + } + execute281(); + } + + /* renamed from: h */ + public final void execute281() { + float[] fArr = MapManager.getInstance().getCurrentMapInfo().spawnPoints; + int i = (this.value255 - 1) * 3; + this.sphereCollider262.value99 = getFloat246(); + if (GameSessionLoop.getInstance().sessionType != 2) { + this.sphereCollider262.execute140(fArr[i], 0.0f, fArr[i + 2]); + } else if (this.value255 == 1) { + this.sphereCollider262.execute140(fArr[3], 0.0f, fArr[5]); + } else if (this.value255 == 2) { + this.sphereCollider262.execute140(fArr[0], 0.0f, fArr[2]); + } + } + + /* renamed from: b */ + public final void execute282(float[] fArr) { + float[] fArr2 = this.sphereCollider262.value98; + fArr2[0] = fArr2[0] + fArr[0]; + fArr2[1] = fArr2[1] + fArr[1]; + fArr2[2] = fArr2[2] + fArr[2]; + } + + /* renamed from: c */ + public final SphereCollider getSphereCollider283(float[] fArr) { + float[] fArr2 = this.sphereCollider262.value98; + this.sphereCollider263.value98[0] = fArr2[0] + fArr[0]; + this.sphereCollider263.value98[1] = fArr2[1] + fArr[1]; + this.sphereCollider263.value98[2] = fArr2[2] + fArr[2]; + this.sphereCollider263.value99 = this.sphereCollider262.value99; + return this.sphereCollider263; + } + + /* renamed from: a */ + public PlayerEntityBase findHitTarget(SphereCollider c0023aw) { + PlayerEntityBase abstractC0052u = null; + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + while (true) { + if (!enumerationKeys.hasMoreElements()) { + break; + } + PlayerEntityBase abstractC0052u2 = (PlayerEntityBase) hashtable.get((Integer) enumerationKeys.nextElement()); + if (abstractC0052u2 != this && abstractC0052u2.sphereCollider262.getBoolean139(c0023aw)) { + abstractC0052u = abstractC0052u2; + break; + } + } + return abstractC0052u; + } + + /* renamed from: a */ + public final boolean getBoolean284(PlayerEntityBase abstractC0052u) { + int iFloor; + int iFloor2; + float[] fArrM289i = abstractC0052u.getFloatArray289(); + float[] fArrM289i2 = getFloatArray289(); + float[] fArr = {fArrM289i[0] - fArrM289i2[0], 0.0f, fArrM289i[2] - fArrM289i2[2]}; + float[] fArr2 = MapManager.getInstance().worldBoundsXZ; + float f = (fArrM289i[2] - fArr2[1]) / 20.0f; + int iFloor3 = f < 1.0f ? 0 : (int) Math.floor(f); + float f2 = (fArrM289i[0] - fArr2[0]) / 20.0f; + int iFloor4 = f2 < 1.0f ? 0 : (int) Math.floor(f2); + float f3 = (fArrM289i2[2] - fArr2[1]) / 20.0f; + int iFloor5 = f3 < 1.0f ? 0 : (int) Math.floor(f3); + float f4 = (fArrM289i2[0] - fArr2[0]) / 20.0f; + int iFloor6 = f4 < 1.0f ? 0 : (int) Math.floor(f4); + float[] fArr3 = {iFloor4 - iFloor6, 0.0f, iFloor3 - iFloor5}; + float[] fArrM263b = VectorMath.getFloatArray263(fArr3); + float[] fArr4 = {(fArrM263b[0] * 20.0f) / 2.0f, 0.0f, (fArrM263b[2] * 20.0f) / 2.0f}; + int i = -1; + int i2 = -1; + int i3 = 0; + while (true) { + float[] fArr5 = {fArrM289i2[0], this.sphereCollider262.value99 / 2.0f, fArrM289i2[2]}; + if (i3 == 0) { + iFloor2 = iFloor6; + iFloor = iFloor5; + } else { + float f5 = fArrM289i2[0] + (i3 * fArr4[0]); + float f6 = fArrM289i2[2] + (i3 * fArr4[2]); + if (fArr[0] >= 0.0f) { + if (f5 > fArrM289i[0]) { + return false; + } + } else if (f5 < fArrM289i[0]) { + return false; + } + if (fArr[2] >= 0.0f) { + if (f6 > fArrM289i[2]) { + return false; + } + } else if (f6 < fArrM289i[2]) { + return false; + } + float f7 = (f6 - fArr2[1]) / 20.0f; + iFloor = f7 < 1.0f ? 0 : (int) Math.floor(f7); + float f8 = (f5 - fArr2[0]) / 20.0f; + iFloor2 = f8 < 1.0f ? 0 : (int) Math.floor(f8); + } + i3++; + if (iFloor2 != i || iFloor != i2) { + Vector vector = MapManager.getInstance().collisionCells[iFloor][iFloor2]; + if (vector != null) { + for (int i4 = 0; i4 < vector.size(); i4++) { + if (((AxisAlignedBoundingBox) vector.elementAt(i4)).getBoolean168(fArrM289i2, fArr)) { + return true; + } + } + } + if (fArr3[0] == 0.0f && fArr3[2] == 0.0f) { + return false; + } + i = iFloor2; + i2 = iFloor; + } + } + } + + /* renamed from: b */ + public final boolean getBoolean285(PlayerEntityBase abstractC0052u) { + float[] fArrM289i = abstractC0052u.getFloatArray289(); + return compute286(fArrM289i[0], fArrM289i[2]); + } + + /* renamed from: a */ + public final boolean compute286(float f, float f2) { + float[] fArrM289i = getFloatArray289(); + float[] fArr = {f - fArrM289i[0], 0.0f, f2 - fArrM289i[2]}; + float[] fArrM287a = compute287(1, 1.0f); + return ((float) Math.toDegrees((double) ((float) FastAcos.getDouble78(((double) VectorMath.getFloat259(fArrM287a, fArr)) / (Math.sqrt((double) (((fArrM287a[0] * fArrM287a[0]) + (fArrM287a[1] * fArrM287a[1])) + (fArrM287a[2] * fArrM287a[2]))) * Math.sqrt((double) (((fArr[0] * fArr[0]) + (fArr[1] * fArr[1])) + (fArr[2] * fArr[2])))))))) <= 40.0f; + } + + /* renamed from: a */ + public final float[] compute287(int i, float f) { + float f2 = 0.0f; + switch (i) { + case 1: + f2 = this.value265 + 180.0f; + break; + case 2: + f2 = this.value265; + break; + case 3: + f2 = this.value265 - 90.0f; + break; + case 4: + f2 = this.value265 + 90.0f; + break; + } + float[] fArr = new float[3]; + double dSin = Math.sin(Math.toRadians(f2)); + double dCos = Math.cos(Math.toRadians(f2)); + if (Math.abs(dCos) == 1.0d) { + fArr[0] = 0.0f; + fArr[2] = (float) (f * dCos); + fArr[1] = 0.0f; + } else if (Math.abs(dSin) == 1.0d) { + fArr[2] = 0.0f; + fArr[0] = (float) (f * dSin); + fArr[1] = 0.0f; + } else { + double d = f; + fArr[0] = (float) (d * dSin); + fArr[2] = (float) (d * dCos); + fArr[1] = 0.0f; + } + return fArr; + } + + /* renamed from: d */ + public final AxisAlignedBoundingBox getAxisAlignedBoundingBox288(float[] fArr) { + MapManager.getInstance(); + SphereCollider c0023awM283c = getSphereCollider283(fArr); + SphereCollider c0023aw = new SphereCollider(c0023awM283c.value98, c0023awM283c.value99 * 2.0f); + float[] fArr2 = this.sphereCollider262.value98; + float f = c0023aw.value99; + float f2 = fArr2[0] - f; + float f3 = fArr2[2] - f; + float f4 = fArr2[0] + f; + float f5 = fArr2[2] + f; + float[] fArr3 = MapManager.getInstance().worldBoundsXZ; + float f6 = (f3 - fArr3[1]) / 20.0f; + int iFloor = f6 < 1.0f ? 0 : (int) Math.floor(f6); + float f7 = (f2 - fArr3[0]) / 20.0f; + int iFloor2 = f7 < 1.0f ? 0 : (int) Math.floor(f7); + float f8 = (f5 - fArr3[1]) / 20.0f; + int iFloor3 = f8 < 1.0f ? 0 : (int) Math.floor(f8); + float f9 = (f4 - fArr3[0]) / 20.0f; + int iFloor4 = f9 < 1.0f ? 0 : (int) Math.floor(f9); + Vector[][] vectorArr = MapManager.getInstance().collisionCells; + for (int i = iFloor; i <= iFloor3; i++) { + for (int i2 = iFloor2; i2 <= iFloor4; i2++) { + if (i >= vectorArr.length || i2 >= vectorArr[i].length) { + return null; + } + if (vectorArr[i][i2] != null) { + Vector vector = vectorArr[i][i2]; + for (int i3 = 0; i3 < vector.size(); i3++) { + AxisAlignedBoundingBox c0025ay = (AxisAlignedBoundingBox) vector.elementAt(i3); + if (c0025ay.getBoolean166(c0023aw)) { + return c0025ay; + } + } + } + } + } + return null; + } + + /* renamed from: i */ + public final float[] getFloatArray289() { + float[] fArr = new float[3]; + this.playerModelBase261.node234.getTranslation(fArr); + return fArr; + } +} diff --git a/p000/PlayerInputController.java b/p000/PlayerInputController.java new file mode 100644 index 0000000..70c2fb7 --- /dev/null +++ b/p000/PlayerInputController.java @@ -0,0 +1,170 @@ +package p000; + +import javax.microedition.m3g.Background; + +/* renamed from: h */ +/* loaded from: microcounterstrike.jar:h.class */ +public class PlayerInputController extends InputStateBase { + + /* renamed from: d */ + private boolean flag193 = false; + + /* renamed from: e */ + private int value194 = 0; + + /* renamed from: a */ + public int value195 = 0; + + /* renamed from: f */ + private int value196 = 1; + + /* renamed from: b */ + public int value197 = 0; + + /* renamed from: g */ + private int value198 = 1; + + public PlayerInputController() { + this.flag93 = new boolean[9]; + } + + /* JADX WARN: Multi-variable type inference failed */ + @Override // p000.InputStateBase + /* renamed from: a */ + public final void execute125() { + PlayerEntityBase abstractC0052u = PlayerManager.getInstance().localPlayer; + Combatant interfaceC0030bc = (Combatant) abstractC0052u; + if (this.flag93[5] || this.flag93[6] || this.flag93[7] || this.flag93[8]) { + abstractC0052u.value260++; + } else { + abstractC0052u.value260 = 0; + } + float f = PlayerEntityBase.value258 * abstractC0052u.value260; + float f2 = f >= PlayerEntityBase.value259 ? PlayerEntityBase.value259 : f; + if (this.flag93[1]) { + execute234((PlayerMovementEntity) abstractC0052u, 1); + } else if (this.flag93[2]) { + execute234((PlayerMovementEntity) abstractC0052u, 2); + } + if (this.flag93[3]) { + execute234((PlayerMovementEntity) abstractC0052u, 3); + } else if (this.flag93[4]) { + execute234((PlayerMovementEntity) abstractC0052u, 4); + } + if (this.flag93[1] || this.flag93[2] || this.flag93[3] || this.flag93[4]) { + if (this.value195 == 0) { + this.value196 = 1; + } else if (this.value195 == 3) { + this.value196 = -1; + } + this.value195 += this.value196; + } else if (this.value195 != 0) { + this.value195--; + } + interfaceC0030bc.getGrenadeController().execute74(MapManager.getInstance().world); + if (this.flag93[5]) { + abstractC0052u.getFloat248(f2); + } else if (this.flag93[6]) { + abstractC0052u.getFloat249(f2); + } + if (this.flag93[7]) { + float fMo250c = abstractC0052u.getFloat250(f2); + Background background = MapManager.getInstance().world.getBackground(); + if (background != null) { + background.setCrop(background.getCropX() - ((int) (fMo250c * (background.getCropWidth() / 60.0f))), background.getCropY(), background.getCropWidth(), background.getCropHeight()); + } + } else if (this.flag93[8]) { + float fMo251d = abstractC0052u.getFloat251(f2); + Background background2 = MapManager.getInstance().world.getBackground(); + if (background2 != null) { + background2.setCrop(background2.getCropX() + ((int) (fMo251d * (background2.getCropWidth() / 60.0f))), background2.getCropY(), background2.getCropWidth(), background2.getCropHeight()); + } + } + if (!this.flag93[0]) { + if (this.value197 != 0) { + this.value197--; + return; + } + return; + } + int i = interfaceC0030bc.getLoadout().getActiveWeaponInfo().weaponCode; + int i2 = interfaceC0030bc.getLoadout().activeSlot; + if (i == 10 && !this.flag193) { + this.flag193 = true; + return; + } + if (i2 == 2 || i2 == 3 || i2 == 4 || i == 11) { + execute126(0, false); + } + if (i2 == 3) { + ((HudRenderer) HudBase.getInstance()).execute311(); + interfaceC0030bc.handleAction(); + return; + } + if (interfaceC0030bc.getLoadout().getActiveAmmo() > 0) { + if (i == 10) { + float f3 = 0.1f * this.value194; + switch (RandomUtil.random237.nextInt(3)) { + case 0: + abstractC0052u.getFloat250(f3); + break; + case 1: + abstractC0052u.getFloat251(f3); + break; + } + this.value194++; + } + if (MainUiCanvasBase.getInstance().soundEnabled) { + if (i == 10) { + SoundManager.getInstance().execute199(1); + } else if (i == 11) { + SoundManager.getInstance().execute199(2); + } else if (i == 20) { + SoundManager.getInstance().execute199(3); + } + } + interfaceC0030bc.handleAction(); + if (i2 == 1 || i2 == 2) { + ((HudRenderer) HudBase.getInstance()).execute310(); + if (interfaceC0030bc.getLoadout().getActiveAmmo() == 0) { + HudBase.getInstance().execute237(4, (String) null); + } + if (this.value197 == 0) { + this.value198 = 1; + } else if (this.value197 == 3) { + this.value198 = -1; + } + this.value197 += this.value198; + } else if (i2 == 4 && interfaceC0030bc.getLoadout().ammoBySlot[2] <= 0) { + interfaceC0030bc.getLoadout().clearSlot(4); + interfaceC0030bc.getLoadout().selectSlot(2); + } + if (i != 10 || this.flag193) { + return; + } + this.flag193 = false; + } + } + + /* renamed from: a */ + private static void execute234(PlayerMovementEntity c0054w, int i) { + float[] fArrM287a = c0054w.compute287(i, 1.0f); + if (c0054w.findHitTarget(c0054w.getSphereCollider283(fArrM287a)) == null) { + float[] fArrM299a = c0054w.getFloatArray299(fArrM287a); + if (fArrM299a[0] == 0.0f && fArrM299a[1] == 0.0f && fArrM299a[2] == 0.0f) { + return; + } + c0054w.execute300(fArrM299a); + } + } + + @Override // p000.InputStateBase + /* renamed from: a */ + public final void execute126(int i, boolean z) { + super.execute126(i, z); + if (i != -1 && i == 0 && z) { + this.flag193 = true; + this.value194 = 0; + } + } +} diff --git a/p000/PlayerManager.java b/p000/PlayerManager.java new file mode 100644 index 0000000..c385e39 --- /dev/null +++ b/p000/PlayerManager.java @@ -0,0 +1,85 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; +import javax.microedition.m3g.World; + +/* renamed from: bb */ +/* loaded from: microcounterstrike.jar:bb.class */ +public final class PlayerManager { + + /* renamed from: c */ + private static PlayerManager instance; + + /* renamed from: a */ + public PlayerEntityBase localPlayer; + + /* renamed from: b */ + public Hashtable playersById; + + private PlayerManager() { + } + + /* renamed from: a */ + public static PlayerManager getInstance() { + if (instance == null) { + instance = new PlayerManager(); + } + return instance; + } + + /* renamed from: a */ + public final void addPlayer(PlayerEntityBase abstractC0052u) { + if (this.playersById == null) { + this.playersById = new Hashtable(); + } + this.playersById.put(new Integer(abstractC0052u.value255), abstractC0052u); + if (abstractC0052u.value255 == 1) { + this.localPlayer = abstractC0052u; + } + } + + /* renamed from: a */ + public final void addAllToWorld(World world) { + Enumeration enumerationKeys = this.playersById.keys(); + while (enumerationKeys.hasMoreElements()) { + ((PlayerEntityBase) this.playersById.get((Integer) enumerationKeys.nextElement())).addToWorld(world); + } + } + + /* renamed from: b */ + public final void respawnAll() { + Enumeration enumerationKeys = this.playersById.keys(); + while (enumerationKeys.hasMoreElements()) { + ((PlayerEntityBase) this.playersById.get((Integer) enumerationKeys.nextElement())).respawn(); + } + } + + /* renamed from: c */ + public final void disposeAll() { + Enumeration enumerationKeys = this.playersById.keys(); + while (enumerationKeys.hasMoreElements()) { + ((PlayerEntityBase) this.playersById.get((Integer) enumerationKeys.nextElement())).removeFromWorld(); + } + this.playersById = null; + } + + /* renamed from: d */ + public final void updateVisibility() { + Enumeration enumerationKeys = this.playersById.keys(); + while (enumerationKeys.hasMoreElements()) { + PlayerEntityBase abstractC0052u = (PlayerEntityBase) this.playersById.get((Integer) enumerationKeys.nextElement()); + if (abstractC0052u.flag266) { + abstractC0052u.playerModelBase261.execute273(true); + abstractC0052u.execute245(); + } else { + abstractC0052u.playerModelBase261.execute273(false); + } + } + } + + /* renamed from: a */ + public final PlayerEntityBase getPlayerById(int i) { + return (PlayerEntityBase) this.playersById.get(new Integer(i)); + } +} diff --git a/p000/PlayerModel.java b/p000/PlayerModel.java new file mode 100644 index 0000000..9c5434d --- /dev/null +++ b/p000/PlayerModel.java @@ -0,0 +1,313 @@ +package p000; + +import java.io.IOException; +import javax.microedition.m3g.Group; +import javax.microedition.m3g.Loader; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.Object3D; +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.World; + +/* renamed from: t */ +/* loaded from: microcounterstrike.jar:t.class */ +public final class PlayerModel extends PlayerModelBase { + + /* renamed from: d */ + public Group group238; + + /* renamed from: e */ + public Group group239; + + /* renamed from: f */ + public Group group240; + + /* renamed from: g */ + public Group group241; + + /* renamed from: r */ + private Group group242; + + /* renamed from: s */ + private Group group243; + + /* renamed from: h */ + public Node node244; + + /* renamed from: i */ + public Node node245; + + /* renamed from: j */ + public Node node246; + + /* renamed from: k */ + public Node node247; + + /* renamed from: l */ + public static float[] value248; + + /* renamed from: m */ + public static float[] value249; + + /* renamed from: t */ + private static PlayerModelBase playerModelBase250; + + /* renamed from: n */ + public static final int[][] CONST_VALUE251 = {new int[]{9, 6}, new int[]{0, 9}, new int[]{0, 9}, new int[]{0, 9}, new int[]{0, 9}}; + + /* renamed from: o */ + public int value252; + + /* renamed from: p */ + public float[][] value253; + + /* renamed from: q */ + public float[][] value254; + + /* JADX WARN: Type inference failed for: r1v7, types: [float[], float[][]] */ + /* JADX WARN: Type inference failed for: r1v9, types: [float[], float[][]] */ + public PlayerModel(PlayerEntityBase abstractC0052u) { + super(abstractC0052u); + float[] fArr = {30.0f, 30.0f, -30.0f, -30.0f}; + this.value252 = -1; + this.value253 = new float[]{new float[]{1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}, new float[]{0.90763855f, 0.2431984f, 0.34201813f, -0.25881195f, 0.96591187f, 0.0f, -0.33035278f, -0.08851814f, 0.939682f}, new float[]{0.64785767f, 0.42536163f, 0.6318054f, -0.4848938f, 0.8700409f, -0.08851814f, -0.5873413f, -0.24901581f, 0.7700043f}, new float[]{0.26921082f, 0.5124817f, 0.81526184f, -0.6360321f, 0.73028564f, -0.24901581f, -0.7230072f, -0.45152283f, 0.52267456f}, new float[]{-0.27770233f, 0.6833954f, 0.67500305f, -0.89030457f, 0.08068085f, -0.447937f, -0.36060333f, -0.72540283f, 0.58613586f}, new float[]{0.32598114f, 0.7307129f, 0.5997009f, -0.83987427f, 0.51504517f, -0.17100525f, -0.43384552f, -0.44792938f, 0.7816925f}}; + this.value254 = new float[]{new float[]{1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}, new float[]{0.9698334f, 0.17100525f, -0.17364502f, -0.17364502f, 0.98480225f, 0.0f, 0.17100525f, 0.03015232f, 0.98480225f}, new float[]{0.8811493f, 0.32901f, -0.33940887f, -0.33940887f, 0.9401245f, 0.03015232f, 0.32900238f, 0.08862877f, 0.9401245f}, new float[]{0.7393646f, 0.46444702f, -0.48724365f, -0.48724365f, 0.8686981f, 0.08862877f, 0.4644394f, 0.17188644f, 0.8686981f}}; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1, types: [javax.microedition.m3g.Object3D[]] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v67, types: [javax.microedition.m3g.Object3D[]] */ + @Override // p000.PlayerModelBase + /* renamed from: a */ + public final Node loadM3G0(World world) { + ?? Load = (Object3D[]) 0; + World[] worldArr = Load; + try { + Load = Loader.load("/res/role/terrorist.m3g"); + worldArr = Load; + } catch (IOException e) { + Load.printStackTrace(); + } + World world2 = null; + for (int i = 0; i < worldArr.length; i++) { + if (worldArr[i] instanceof World) { + world2 = worldArr[i]; + } + } + this.node235 = world2.find(124); + world2.removeChild(this.node235); + if (playerModelBase250 != null) { + PlayerModelBase.execute272(playerModelBase250.node235, this.node235); + } + if (((Combatant) this.playerEntityBase236).getTeamId() == 0) { + this.node235.getAppearance(0).getTexture(0).setImage(ResourceLoader.loadImages132("/res/role/c_32X32.png")); + } + this.node244 = this.node235.find(114); + this.node244.setRenderingEnable(true); + this.node245 = this.node235.find(116); + this.node245.setRenderingEnable(false); + this.node246 = this.node235.find(118); + this.node246.setRenderingEnable(false); + this.node247 = this.node235.find(120); + this.node247.setRenderingEnable(false); + Group skeleton = this.node235.getSkeleton(); + this.group238 = skeleton.find(108); + this.group239 = skeleton.find(107); + this.group240 = skeleton.find(106); + this.group241 = skeleton.find(101); + this.group242 = skeleton.find(111); + this.group243 = skeleton.find(121); + world.addChild(this.node235); + Transform transform = new Transform(); + world.getTransformTo(this.node235, transform); + float[] fArr = {0.0f, 1.0f, 0.0f, 0.0f}; + transform.transform(fArr); + this.node235.postRotate(180.0f, fArr[0], fArr[1], fArr[2]); + if (playerModelBase250 == null) { + execute278(world); + playerModelBase250 = this; + } + this.node234 = this.node235; + return this.node235; + } + + @Override // p000.PlayerModelBase + /* renamed from: a */ + public final void execute271() { + super.execute271(); + this.group238 = null; + this.group239 = null; + this.group240 = null; + this.group241 = null; + playerModelBase250 = null; + } + + /* renamed from: b */ + private void execute278(World world) { + Transform transform = new Transform(); + world.getTransformTo(this.group240, transform); + float[] fArr = {1.0f, 0.0f, 0.0f, 0.0f}; + transform.transform(fArr); + value248 = new float[3]; + value248[0] = fArr[0]; + value248[1] = fArr[1]; + value248[2] = fArr[2]; + float[] fArr2 = {0.0f, 1.0f, 0.0f, 0.0f}; + transform.transform(fArr2); + value249 = new float[3]; + value249[0] = fArr2[0]; + value249[1] = fArr2[1]; + value249[2] = fArr2[2]; + } + + /* renamed from: b */ + public final void execute279() { + if (this.value252 == -1) { + this.value252 = 0; + } + } + + /* renamed from: c */ + public final void execute280() { + if (this.value252 >= 0) { + this.value252++; + Transform transform = new Transform(); + this.group242.getTransform(transform); + float[] fArr = new float[16]; + transform.get(fArr); + Transform transform2 = new Transform(); + this.group243.getTransform(transform2); + float[] fArr2 = new float[16]; + transform2.get(fArr2); + switch (this.value252) { + case 1: + fArr[0] = this.value253[1][0]; + fArr[1] = this.value253[1][1]; + fArr[2] = this.value253[1][2]; + fArr[4] = this.value253[1][3]; + fArr[5] = this.value253[1][4]; + fArr[6] = this.value253[1][5]; + fArr[8] = this.value253[1][6]; + fArr[9] = this.value253[1][7]; + fArr[10] = this.value253[1][8]; + fArr2[0] = this.value254[1][0]; + fArr2[1] = this.value254[1][1]; + fArr2[2] = this.value254[1][2]; + fArr2[4] = this.value254[1][3]; + fArr2[5] = this.value254[1][4]; + fArr2[6] = this.value254[1][5]; + fArr2[8] = this.value254[1][6]; + fArr2[9] = this.value254[1][7]; + fArr2[10] = this.value254[1][8]; + break; + case 2: + fArr[0] = this.value253[2][0]; + fArr[1] = this.value253[2][1]; + fArr[2] = this.value253[2][2]; + fArr[4] = this.value253[2][3]; + fArr[5] = this.value253[2][4]; + fArr[6] = this.value253[2][5]; + fArr[8] = this.value253[2][6]; + fArr[9] = this.value253[2][7]; + fArr[10] = this.value253[2][8]; + fArr2[0] = this.value254[2][0]; + fArr2[1] = this.value254[2][1]; + fArr2[2] = this.value254[2][2]; + fArr2[4] = this.value254[2][3]; + fArr2[5] = this.value254[2][4]; + fArr2[6] = this.value254[2][5]; + fArr2[8] = this.value254[2][6]; + fArr2[9] = this.value254[2][7]; + fArr2[10] = this.value254[2][8]; + break; + case 3: + fArr[0] = this.value253[3][0]; + fArr[1] = this.value253[3][1]; + fArr[2] = this.value253[3][2]; + fArr[4] = this.value253[3][3]; + fArr[5] = this.value253[3][4]; + fArr[6] = this.value253[3][5]; + fArr[8] = this.value253[3][6]; + fArr[9] = this.value253[3][7]; + fArr[10] = this.value253[3][8]; + fArr2[0] = this.value254[3][0]; + fArr2[1] = this.value254[3][1]; + fArr2[2] = this.value254[3][2]; + fArr2[4] = this.value254[3][3]; + fArr2[5] = this.value254[3][4]; + fArr2[6] = this.value254[3][5]; + fArr2[8] = this.value254[3][6]; + fArr2[9] = this.value254[3][7]; + fArr2[10] = this.value254[3][8]; + break; + case 4: + fArr[0] = this.value253[4][0]; + fArr[1] = this.value253[4][1]; + fArr[2] = this.value253[4][2]; + fArr[4] = this.value253[4][3]; + fArr[5] = this.value253[4][4]; + fArr[6] = this.value253[4][5]; + fArr[8] = this.value253[4][6]; + fArr[9] = this.value253[4][7]; + fArr[10] = this.value253[4][8]; + fArr2[0] = this.value254[2][0]; + fArr2[1] = this.value254[2][1]; + fArr2[2] = this.value254[2][2]; + fArr2[4] = this.value254[2][3]; + fArr2[5] = this.value254[2][4]; + fArr2[6] = this.value254[2][5]; + fArr2[8] = this.value254[2][6]; + fArr2[9] = this.value254[2][7]; + fArr2[10] = this.value254[2][8]; + break; + case 5: + fArr[0] = this.value253[5][0]; + fArr[1] = this.value253[5][1]; + fArr[2] = this.value253[5][2]; + fArr[4] = this.value253[5][3]; + fArr[5] = this.value253[5][4]; + fArr[6] = this.value253[5][5]; + fArr[8] = this.value253[5][6]; + fArr[9] = this.value253[5][7]; + fArr[10] = this.value253[5][8]; + fArr2[0] = this.value254[1][0]; + fArr2[1] = this.value254[1][1]; + fArr2[2] = this.value254[1][2]; + fArr2[4] = this.value254[1][3]; + fArr2[5] = this.value254[1][4]; + fArr2[6] = this.value254[1][5]; + fArr2[8] = this.value254[1][6]; + fArr2[9] = this.value254[1][7]; + fArr2[10] = this.value254[1][8]; + break; + case 6: + fArr[0] = this.value253[0][0]; + fArr[1] = this.value253[0][1]; + fArr[2] = this.value253[0][2]; + fArr[4] = this.value253[0][3]; + fArr[5] = this.value253[0][4]; + fArr[6] = this.value253[0][5]; + fArr[8] = this.value253[0][6]; + fArr[9] = this.value253[0][7]; + fArr[10] = this.value253[0][8]; + fArr2[0] = this.value254[0][0]; + fArr2[1] = this.value254[0][1]; + fArr2[2] = this.value254[0][2]; + fArr2[4] = this.value254[0][3]; + fArr2[5] = this.value254[0][4]; + fArr2[6] = this.value254[0][5]; + fArr2[8] = this.value254[0][6]; + fArr2[9] = this.value254[0][7]; + fArr2[10] = this.value254[0][8]; + break; + } + transform.set(fArr); + this.group242.setTransform(transform); + transform2.set(fArr2); + this.group243.setTransform(transform2); + if (this.value252 >= 6) { + this.value252 = -1; + } + } + } +} diff --git a/p000/PlayerModelBase.java b/p000/PlayerModelBase.java new file mode 100644 index 0000000..cffbbd3 --- /dev/null +++ b/p000/PlayerModelBase.java @@ -0,0 +1,59 @@ +package p000; + +import javax.microedition.m3g.Appearance; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.Node; +import javax.microedition.m3g.VertexArray; +import javax.microedition.m3g.World; + +/* renamed from: q */ +/* loaded from: microcounterstrike.jar:q.class */ +public abstract class PlayerModelBase { + + /* renamed from: a */ + public Node node234; + + /* renamed from: b */ + public Node node235; + + /* renamed from: c */ + public PlayerEntityBase playerEntityBase236; + + public PlayerModelBase() { + } + + public PlayerModelBase(PlayerEntityBase abstractC0052u) { + this.playerEntityBase236 = abstractC0052u; + } + + /* renamed from: a */ + public abstract Node loadM3G0(World world); + + /* renamed from: a */ + public void execute271() { + this.playerEntityBase236 = null; + this.node234 = null; + this.node235 = null; + } + + /* renamed from: a */ + public static void execute272(Mesh mesh, Mesh mesh2) { + mesh2.setAppearance(0, (Appearance) null); + mesh2.setAppearance(0, mesh.getAppearance(0)); + mesh2.getVertexBuffer().setNormals(mesh.getVertexBuffer().getNormals()); + float[] fArr = new float[4]; + VertexArray positions = mesh.getVertexBuffer().getPositions(fArr); + float[] fArr2 = {fArr[1], fArr[2], fArr[3]}; + mesh2.getVertexBuffer().setPositions(positions, fArr[0], fArr2); + VertexArray texCoords = mesh.getVertexBuffer().getTexCoords(0, fArr); + fArr2[0] = fArr[1]; + fArr2[1] = fArr[2]; + fArr2[2] = fArr[3]; + mesh2.getVertexBuffer().setTexCoords(0, texCoords, fArr[0], fArr2); + } + + /* renamed from: a */ + public final void execute273(boolean z) { + this.node234.setRenderingEnable(z); + } +} diff --git a/p000/PlayerMovementEntity.java b/p000/PlayerMovementEntity.java new file mode 100644 index 0000000..1cf2844 --- /dev/null +++ b/p000/PlayerMovementEntity.java @@ -0,0 +1,154 @@ +package p000; + +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.World; + +/* renamed from: w */ +/* loaded from: microcounterstrike.jar:w.class */ +public class PlayerMovementEntity extends PlayerEntityBase { + + /* renamed from: a */ + public Transform transform276; + + /* renamed from: b */ + public Transform transform277; + + /* renamed from: c */ + public Transform transform278; + + /* renamed from: d */ + private float value279; + + public PlayerMovementEntity(int i, String str, int i2, PlayerModelBase abstractC0048q) { + super(i, str, i2); + this.transform276 = new Transform(); + this.transform277 = new Transform(); + this.transform278 = new Transform(); + this.value279 = 0.0f; + this.playerModelBase261 = abstractC0048q; + this.playerModelBase261.playerEntityBase236 = this; + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public void addToWorld(World world) { + this.playerModelBase261.loadM3G0(world).setUserObject(this); + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public void removeFromWorld() { + super.removeFromWorld(); + this.transform276 = null; + this.transform277 = null; + this.transform278 = null; + } + + @Override // p000.PlayerEntityBase + /* renamed from: b */ + public void respawn() { + this.transform276.setIdentity(); + this.transform277.setIdentity(); + this.transform278.setIdentity(); + super.respawn(); + } + + @Override // p000.PlayerEntityBase + /* renamed from: c */ + public final void execute245() { + this.playerModelBase261.node234.setTransform(this.transform276); + } + + @Override // p000.PlayerEntityBase + /* renamed from: d */ + public final float getFloat246() { + return 1.0f; + } + + /* JADX WARN: Removed duplicated region for block: B:29:0x025e */ + /* renamed from: a */ + /* + Code decompiled incorrectly, please refer to instructions dump. + To view partially-correct code enable 'Show inconsistent code' option in preferences + */ + public final float[] getFloatArray299(float[] r11) { + /* + Method dump skipped, instructions count: 626 + To view this dump change 'Code comments level' option to 'DEBUG' + */ + throw new UnsupportedOperationException("Method not decompiled: p000.PlayerMovementEntity.getFloatArray299(float[]):float[]"); + } + + @Override // p000.PlayerEntityBase + /* renamed from: a */ + public final float getFloat248(float f) { + this.value264 += f; + if (this.value264 > 75.0f) { + this.value264 = 75.0f; + return 0.0f; + } + this.transform276.postRotate(f, 1.0f, 0.0f, 0.0f); + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: b */ + public final float getFloat249(float f) { + this.value264 -= f; + if (this.value264 < -75.0f) { + this.value264 = -75.0f; + return 0.0f; + } + this.transform276.postRotate(-f, 1.0f, 0.0f, 0.0f); + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: c */ + public final float getFloat250(float f) { + this.transform276.postRotate(-this.value264, 1.0f, 0.0f, 0.0f); + this.transform276.postRotate(f, 0.0f, 1.0f, 0.0f); + this.transform276.postRotate(this.value264, 1.0f, 0.0f, 0.0f); + this.value265 += f; + if (GameSessionLoop.getInstance().sessionType == 1 || GameSessionLoop.getInstance().sessionType == 2) { + this.transform277.postRotate(f, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value279 += f; + if (this.value279 >= 45.0f) { + execute301(); + } + } + return f; + } + + @Override // p000.PlayerEntityBase + /* renamed from: d */ + public final float getFloat251(float f) { + this.transform276.postRotate(-this.value264, 1.0f, 0.0f, 0.0f); + this.transform276.postRotate(-f, 0.0f, 1.0f, 0.0f); + this.transform276.postRotate(this.value264, 1.0f, 0.0f, 0.0f); + this.value265 -= f; + if (GameSessionLoop.getInstance().sessionType == 1 || GameSessionLoop.getInstance().sessionType == 2) { + this.transform277.postRotate(-f, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value279 -= f; + if (this.value279 <= -45.0f) { + execute301(); + } + } + return f; + } + + /* renamed from: e */ + public final void execute300(float[] fArr) { + execute282(fArr); + this.playerModelBase261.node234.translate(fArr[0], fArr[1], fArr[2]); + if (GameSessionLoop.getInstance().sessionType == 1 || GameSessionLoop.getInstance().sessionType == 2) { + execute301(); + } + } + + /* renamed from: e */ + private void execute301() { + this.transform278.postRotate(this.value279, PlayerModel.value249[0], PlayerModel.value249[1], PlayerModel.value249[2]); + this.value279 = 0.0f; + } +} diff --git a/p000/RandomUtil.java b/p000/RandomUtil.java new file mode 100644 index 0000000..55dca74 --- /dev/null +++ b/p000/RandomUtil.java @@ -0,0 +1,11 @@ +package p000; + +import java.util.Random; + +/* renamed from: s */ +/* loaded from: microcounterstrike.jar:s.class */ +public final class RandomUtil { + + /* renamed from: a */ + public static Random random237 = new Random(); +} diff --git a/p000/RemotePlayer.java b/p000/RemotePlayer.java new file mode 100644 index 0000000..bce5969 --- /dev/null +++ b/p000/RemotePlayer.java @@ -0,0 +1,163 @@ +package p000; + +import javax.microedition.m3g.Camera; +import javax.microedition.m3g.RayIntersection; +import javax.microedition.m3g.World; + +/* renamed from: be */ +/* loaded from: microcounterstrike.jar:be.class */ +public final class RemotePlayer extends NetworkPlayerEntity implements Combatant { + + /* renamed from: r */ + public int value147; + + /* renamed from: s */ + public int value148; + + /* renamed from: t */ + public WeaponLoadout weaponLoadout149; + + /* renamed from: u */ + public GrenadeController grenadeController150; + + /* renamed from: x */ + private AnimatedBillboardSprite animatedBillboardSprite151; + + /* renamed from: v */ + public boolean flag152; + + /* renamed from: w */ + public boolean flag153; + + public RemotePlayer(int i, String str, int i2, int i3) { + super(i, str, i3); + this.flag152 = false; + this.flag153 = false; + this.value147 = i2; + } + + @Override // p000.NetworkPlayerEntity, p000.PlayerEntityBase + /* renamed from: a */ + public final void addToWorld(World world) { + super.addToWorld(world); + execute204(CameraManager.getInstance().getCamera121("MAIN")); + this.weaponLoadout149 = new WeaponLoadout(); + if (this.grenadeController150 == null) { + this.grenadeController150 = new GrenadeController(this); + } + } + + @Override // p000.NetworkPlayerEntity, p000.PlayerEntityBase + /* renamed from: a */ + public final void removeFromWorld() { + super.removeFromWorld(); + this.weaponLoadout149.dispose(); + this.weaponLoadout149 = null; + this.grenadeController150.execute76(); + this.grenadeController150 = null; + this.animatedBillboardSprite151 = null; + } + + @Override // p000.NetworkPlayerEntity, p000.PlayerEntityBase + /* renamed from: b */ + public final void respawn() { + super.respawn(); + if (this.value148 <= 0) { + this.weaponLoadout149.resetToDefaultLoadout(); + } + this.weaponLoadout149.addWeaponOrAmmo((WeaponInfo) WeaponLoadout.weaponCatalog.elementAt(WeaponLoadout.defaultPrimaryWeaponId)); + this.weaponLoadout149.selectSlot(1); + this.value148 = 100; + } + + @Override // p000.Combatant + /* renamed from: e */ + public final int handleAction() { + this.animatedBillboardSprite151.execute183(true); + LocalPlayer c0008ah = (LocalPlayer) PlayerManager.getInstance().localPlayer; + if (RandomUtil.random237.nextInt(5) != 0) { + return 2; + } + c0008ah.onHit(this, this.weaponLoadout149.activeSlot, null, null); + this.flag153 = true; + return 1; + } + + @Override // p000.Combatant + /* renamed from: a */ + public final int onHit(PlayerEntityBase abstractC0052u, int i, RayIntersection rayIntersection, World world) { + if (this.value148 <= 0) { + return 0; + } + if (i != 4) { + ParticleEffectManager.getInstance().execute292(1, rayIntersection, world, CameraManager.getInstance().camera89); + } + int iM205a = getInt205(abstractC0052u, i); + int i2 = iM205a == 0 ? 1 : iM205a; + execute203(i2); + if (this.value148 <= 0) { + execute256(0); + ((RoundBasedGameMode) GameSessionLoop.getInstance()).execute123(this); + } + return i2; + } + + /* renamed from: b */ + private void execute203(int i) { + this.value148 -= i; + if (this.value148 < 0) { + this.value148 = 0; + } + this.flag152 = true; + } + + /* renamed from: a */ + private void execute204(Camera camera) { + this.animatedBillboardSprite151 = MuzzleFlashManager.getInstance().getAnimatedBillboardSprite209(camera, 1); + ((PlayerModel) this.playerModelBase261).group238.addChild(this.animatedBillboardSprite151.mesh121); + this.animatedBillboardSprite151.mesh121.translate(-0.03f, 2.0f, -0.2f); + } + + /* renamed from: a */ + private int getInt205(PlayerEntityBase abstractC0052u, int i) { + LocalPlayer c0008ah = (LocalPlayer) abstractC0052u; + int iNextInt = 0; + if (i == 1) { + iNextInt = c0008ah.loadout.getActiveWeaponInfo().weaponCode == 11 ? this.value148 : RandomUtil.random237.nextInt(c0008ah.loadout.getActiveWeaponInfo().damage); + } else if (i == 2 || i == 3) { + iNextInt = RandomUtil.random237.nextInt(c0008ah.loadout.getActiveWeaponInfo().damage); + } else if (i == 4) { + iNextInt = RandomUtil.random237.nextInt(6) * 20; + } + return iNextInt; + } + + /* renamed from: a */ + public final void execute206(boolean z) { + this.animatedBillboardSprite151.execute183(z); + } + + @Override // p000.Combatant + /* renamed from: j */ + public final int getHealth() { + return this.value148; + } + + @Override // p000.Combatant + /* renamed from: m */ + public final int getTeamId() { + return this.value147; + } + + @Override // p000.Combatant + /* renamed from: k */ + public final WeaponLoadout getLoadout() { + return this.weaponLoadout149; + } + + @Override // p000.Combatant + /* renamed from: l */ + public final GrenadeController getGrenadeController() { + return this.grenadeController150; + } +} diff --git a/p000/ResourceLoader.java b/p000/ResourceLoader.java new file mode 100644 index 0000000..31c3828 --- /dev/null +++ b/p000/ResourceLoader.java @@ -0,0 +1,166 @@ +package p000; + +import java.io.IOException; +import javax.microedition.lcdui.Image; +import javax.microedition.m3g.Appearance; +import javax.microedition.m3g.CompositingMode; +import javax.microedition.m3g.Group; +import javax.microedition.m3g.Image2D; +import javax.microedition.m3g.Loader; +import javax.microedition.m3g.Mesh; +import javax.microedition.m3g.PolygonMode; +import javax.microedition.m3g.Texture2D; +import javax.microedition.m3g.Transform; +import javax.microedition.m3g.TriangleStripArray; +import javax.microedition.m3g.VertexArray; +import javax.microedition.m3g.VertexBuffer; + +/* renamed from: au */ +/* loaded from: microcounterstrike.jar:au.class */ +public final class ResourceLoader { + /* renamed from: a */ + public static Image2D loadM3G129(String str) { + Image2D image2D = null; + try { + image2D = (Image2D) Loader.load(str)[0]; + } catch (Exception unused) { + System.out.println(new StringBuffer("Cannot make image from ").append(str).toString()); + } + return image2D; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1, types: [javax.microedition.m3g.Image2D[]] */ + /* JADX WARN: Type inference failed for: r0v10 */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.io.IOException] */ + /* renamed from: a */ + public static Image2D[] loadImages130(String str, int i, int i2) { + ?? r0 = new Image2D[i]; + try { + Image imageCreateImage = Image.createImage(str); + for (int i3 = 0; i3 < i; i3++) { + Image imageCreateImage2 = Image.createImage(imageCreateImage, i3 * i2, 0, i2, i2, 0); + r0 = r0; + r0[i3] = new Image2D(100, imageCreateImage2); + } + } catch (IOException e) { + r0.printStackTrace(); + } + return r0; + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v1, types: [javax.microedition.m3g.Image2D[]] */ + /* JADX WARN: Type inference failed for: r0v2, types: [java.io.IOException] */ + /* JADX WARN: Type inference failed for: r0v9 */ + /* renamed from: a */ + public static Image2D[] loadImages131(String str, int i, int i2, Image[] imageArr) { + ?? r0 = new Image2D[i]; + try { + Image imageCreateImage = Image.createImage(str); + for (int i3 = 0; i3 < i; i3++) { + imageArr[i3] = Image.createImage(imageCreateImage, i3 * i2, 0, i2, i2, 0); + r0 = r0; + r0[i3] = new Image2D(100, imageArr[i3]); + } + } catch (IOException e) { + r0.printStackTrace(); + } + return r0; + } + + /* renamed from: b */ + public static Image2D loadImages132(String str) { + Image imageCreateImage = null; + Image image = null; + try { + imageCreateImage = Image.createImage(str); + image = imageCreateImage; + } catch (IOException e) { + imageCreateImage.printStackTrace(); + } + return new Image2D(100, image); + } + + /* renamed from: a */ + public static Mesh loadM3G(String str, int i) { + short[] sArr = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0}; + short[] sArr2 = {0, 255, 255, 255, 255, 0, 0, 0}; + VertexArray vertexArray = new VertexArray(sArr.length / 3, 3, 2); + vertexArray.set(0, sArr.length / 3, sArr); + VertexArray vertexArray2 = new VertexArray(sArr2.length / 2, 2, 2); + vertexArray2.set(0, sArr2.length / 2, sArr2); + VertexBuffer vertexBuffer = new VertexBuffer(); + vertexBuffer.setPositions(vertexArray, 1.0f, (float[]) null); + vertexBuffer.setTexCoords(0, vertexArray2, 0.003921569f, (float[]) null); + TriangleStripArray triangleStripArray = new TriangleStripArray(new int[]{0, 1, 3, 2}, new int[]{4}); + Appearance appearance = new Appearance(); + PolygonMode polygonMode = new PolygonMode(); + polygonMode.setCulling(i); + appearance.setPolygonMode(polygonMode); + CompositingMode compositingMode = new CompositingMode(); + compositingMode.setBlending(64); + appearance.setCompositingMode(compositingMode); + try { + Texture2D texture2D = new Texture2D(loadImages132(str)); + texture2D.setBlending(228); + texture2D.setWrapping(240, 240); + texture2D.setFiltering(210, 210); + appearance.setTexture(0, texture2D); + } catch (Exception e) { + System.out.println(e); + } + return new Mesh(vertexBuffer, triangleStripArray, appearance); + } + + /* renamed from: a */ + public static float[] getFloatArray134(Mesh mesh, Group group) { + Transform transform = new Transform(); + transform.setIdentity(); + float[] fArr = new float[4]; + VertexArray positions = mesh.getVertexBuffer().getPositions(fArr); + float[] fArr2 = new float[mesh.getVertexBuffer().getVertexCount() * 4]; + transform.transform(positions, fArr2, false); + float f = fArr[0]; + float f2 = fArr[1]; + float f3 = fArr[2]; + float f4 = fArr[3]; + for (int i = 0; i < fArr2.length; i++) { + fArr2[i] = fArr2[i] * f; + if (i % 4 == 0) { + int i2 = i; + fArr2[i2] = fArr2[i2] + f2; + } + if (i % 4 == 1) { + int i3 = i; + fArr2[i3] = fArr2[i3] + f3; + } + if (i % 4 == 2) { + int i4 = i; + fArr2[i4] = fArr2[i4] + f4; + } + } + Transform transform2 = new Transform(); + transform2.setIdentity(); + mesh.getTransformTo(group, transform2); + transform2.get(new float[16]); + float[] fArr3 = new float[3]; + mesh.getTranslation(fArr3); + transform2.transform(fArr2); + for (int i5 = 0; i5 < fArr2.length; i5++) { + if (i5 % 4 == 0) { + int i6 = i5; + fArr2[i6] = fArr2[i6] + fArr3[0]; + } + if (i5 % 4 == 1) { + int i7 = i5; + fArr2[i7] = fArr2[i7] + fArr3[1]; + } + if (i5 % 4 == 2) { + int i8 = i5; + fArr2[i8] = fArr2[i8] + fArr3[2]; + } + } + return fArr2; + } +} diff --git a/p000/RoundBasedGameMode.java b/p000/RoundBasedGameMode.java new file mode 100644 index 0000000..0ea3451 --- /dev/null +++ b/p000/RoundBasedGameMode.java @@ -0,0 +1,76 @@ +package p000; + +import java.util.Enumeration; +import java.util.Hashtable; + +/* renamed from: ar */ +/* loaded from: microcounterstrike.jar:ar.class */ +public class RoundBasedGameMode extends GameSessionLoop { + + /* renamed from: e */ + private int value90 = 0; + + /* renamed from: f */ + private int value91 = 0; + + @Override // p000.GameSessionLoop + /* renamed from: c */ + public final void onSessionStart() { + PlayerManager.getInstance().respawnAll(); + if (PlatformServices.getInstance().getBoolean141()) { + BulletHoleManager.getInstance().execute305(MapManager.getInstance().world); + } + } + + @Override // p000.GameSessionLoop + /* renamed from: d */ + public final void onRoundStart() { + InputStateBase.getInstance().execute126(-1, false); + } + + @Override // p000.GameSessionLoop + /* renamed from: e */ + public final void onSessionEnd() { + start(); + } + + @Override // p000.GameSessionLoop + /* renamed from: f */ + public final void cleanupNetworking() { + super.cleanupNetworking(); + this.value90 = 0; + this.value91 = 0; + GameLoadingThread.getInstance(); + GameLoadingThread.execute98(); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* renamed from: a */ + public final void execute123(PlayerEntityBase abstractC0052u) { + Combatant interfaceC0030bc = (Combatant) abstractC0052u; + int iMo92m = interfaceC0030bc.getTeamId(); + boolean z = true; + Hashtable hashtable = PlayerManager.getInstance().playersById; + Enumeration enumerationKeys = hashtable.keys(); + while (true) { + if (!enumerationKeys.hasMoreElements()) { + break; + } + Combatant interfaceC0030bc2 = (Combatant) hashtable.get((Integer) enumerationKeys.nextElement()); + if (interfaceC0030bc2.getTeamId() == iMo92m && interfaceC0030bc2.getHealth() > 0) { + z = false; + break; + } + } + PlayerManager.getInstance(); + if (z) { + if (interfaceC0030bc.getTeamId() == 0) { + this.roundEndTriggered = 2; + this.value91++; + } else { + this.roundEndTriggered = 1; + this.value90++; + } + } + } +} diff --git a/p000/SceneRootNode.java b/p000/SceneRootNode.java new file mode 100644 index 0000000..3363a8a --- /dev/null +++ b/p000/SceneRootNode.java @@ -0,0 +1,17 @@ +package p000; + +import javax.microedition.m3g.Node; +import javax.microedition.m3g.World; + +/* renamed from: a */ +/* loaded from: microcounterstrike.jar:a.class */ +public final class SceneRootNode extends PlayerModelBase { + @Override // p000.PlayerModelBase + /* renamed from: a */ + public final Node loadM3G0(World world) { + this.node234 = CameraManager.getInstance().getCamera121("MAIN"); + world.addChild(this.node234); + this.node235 = this.node234; + return this.node235; + } +} diff --git a/p000/SoundManager.java b/p000/SoundManager.java new file mode 100644 index 0000000..65b7c30 --- /dev/null +++ b/p000/SoundManager.java @@ -0,0 +1,141 @@ +package p000; + +import javax.microedition.media.Player; +import javax.microedition.media.PlayerListener; + +/* renamed from: bd */ +/* loaded from: microcounterstrike.jar:bd.class */ +public final class SoundManager implements PlayerListener { + + /* renamed from: a */ + private static SoundManager soundManager136; + + /* renamed from: b */ + private Player[] playerArr137; + + /* renamed from: c */ + private Player[] playerArr138; + + /* renamed from: d */ + private Player[] playerArr139; + + /* renamed from: e */ + private Player[] playerArr140; + + /* renamed from: f */ + private Player[] playerArr141; + + /* renamed from: g */ + private int value142; + + /* renamed from: h */ + private int value143; + + /* renamed from: i */ + private int value144; + + /* renamed from: j */ + private int value145; + + /* renamed from: k */ + private int value146; + + private SoundManager() { + } + + /* renamed from: a */ + public static SoundManager getInstance() { + if (soundManager136 == null) { + soundManager136 = new SoundManager(); + } + return soundManager136; + } + + /* renamed from: a */ + public final void execute199(int i) { + switch (i) { + case 1: + execute200(this.playerArr137[this.value142]); + this.value142 = (this.value142 + 1) % 4; + break; + case 2: + execute200(this.playerArr138[this.value143]); + this.value143 = (this.value143 + 1) % 2; + break; + case 3: + execute200(this.playerArr139[this.value144]); + this.value144 = (this.value144 + 1) % 2; + break; + case 4: + execute200(this.playerArr140[this.value145]); + this.value145 = (this.value145 + 1) % 1; + break; + case 21: + execute200(this.playerArr141[this.value146]); + this.value146 = (this.value146 + 1) % 4; + break; + } + } + + /* renamed from: a */ + private static void execute200(Player player) { + if (player == null || player.getState() != 300) { + return; + } + try { + player.setMediaTime(0L); + player.start(); + } catch (Exception unused) { + System.out.println("Could not play sound "); + } + } + + public final void playerUpdate(Player player, String str, Object obj) { + if (str == "endOfMedia") { + try { + player.stop(); + player.setMediaTime(0L); + } catch (Exception unused) { + } + } + } + + /* renamed from: c */ + private void execute201() { + if (this.playerArr137 != null) { + for (int i = 0; i < 4; i++) { + this.playerArr137[i].close(); + } + } + if (this.playerArr138 != null) { + for (int i2 = 0; i2 < 2; i2++) { + this.playerArr138[i2].close(); + } + } + if (this.playerArr139 != null) { + for (int i3 = 0; i3 < 2; i3++) { + this.playerArr139[i3].close(); + } + } + if (this.playerArr140 != null) { + for (int i4 = 0; i4 < 1; i4++) { + this.playerArr140[0].close(); + } + } + if (this.playerArr141 != null) { + for (int i5 = 0; i5 < 4; i5++) { + this.playerArr141[i5].close(); + } + } + } + + /* renamed from: b */ + public final void execute202() { + execute201(); + this.playerArr137 = null; + this.playerArr138 = null; + this.playerArr139 = null; + this.playerArr140 = null; + this.playerArr141 = null; + } +} diff --git a/p000/SphereCollider.java b/p000/SphereCollider.java new file mode 100644 index 0000000..1769b5a --- /dev/null +++ b/p000/SphereCollider.java @@ -0,0 +1,35 @@ +package p000; + +/* renamed from: aw */ +/* loaded from: microcounterstrike.jar:aw.class */ +public final class SphereCollider { + + /* renamed from: a */ + public float[] value98; + + /* renamed from: b */ + public float value99; + + public SphereCollider() { + this.value98 = new float[3]; + } + + public SphereCollider(float[] fArr, float f) { + this.value98 = new float[3]; + this.value98 = fArr; + this.value99 = f; + } + + /* renamed from: a */ + public final boolean getBoolean139(SphereCollider c0023aw) { + float[] fArr = c0023aw.value98; + return (((fArr[0] - this.value98[0]) * (fArr[0] - this.value98[0])) + ((fArr[1] - this.value98[1]) * (fArr[1] - this.value98[1]))) + ((fArr[2] - this.value98[2]) * (fArr[2] - this.value98[2])) <= (this.value99 + c0023aw.value99) * (this.value99 + c0023aw.value99); + } + + /* renamed from: a */ + public final void execute140(float f, float f2, float f3) { + this.value98[0] = f; + this.value98[1] = f2; + this.value98[2] = f3; + } +} diff --git a/p000/SplashScreen.java b/p000/SplashScreen.java new file mode 100644 index 0000000..1fe4d9a --- /dev/null +++ b/p000/SplashScreen.java @@ -0,0 +1,87 @@ +package p000; + +import com.m3gworks.engine.GameAppMidlet; +import javax.microedition.lcdui.Canvas; +import javax.microedition.lcdui.Graphics; +import javax.microedition.lcdui.Image; + +/* renamed from: e */ +/* loaded from: microcounterstrike.jar:e.class */ +public final class SplashScreen extends Canvas implements Runnable { + + /* renamed from: b */ + private int value173 = getWidth(); + + /* renamed from: e */ + private int value176 = 0; + + /* renamed from: a */ + private static Image image172 = null; + + /* renamed from: c */ + private static int value174 = 10; + + /* renamed from: d */ + private static int value175 = 1000; + + private SplashScreen() { + setFullScreenMode(true); + } + + public final void paint(Graphics graphics) { + graphics.setColor(0, 0, 0); + graphics.fillRect(0, 0, getWidth(), getHeight()); + graphics.drawImage(image172, this.value173, getHeight() / 2, 6); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* JADX WARN: Type inference failed for: r0v16 */ + /* JADX WARN: Type inference failed for: r0v17 */ + /* JADX WARN: Type inference failed for: r0v2 */ + /* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Throwable] */ + /* JADX WARN: Type inference failed for: r0v9, types: [long] */ + @Override // java.lang.Runnable + public final void run() throws InterruptedException { + while (true) { + int i = this.value173; + ?? r0 = i; + if (i <= (getWidth() - image172.getWidth()) / 2) { + this.value176 += value174; + int i2 = this.value176; + r0 = i2; + if (i2 > value175) { + execute225(); + GameAppMidlet.getInstance().display.setCurrent(MainUiCanvasBase.getInstance()); + MainUiCanvasBase.getInstance().execute37(); + return; + } + } + try { + r0 = value174; + Thread.sleep(r0); + } catch (InterruptedException e) { + r0.printStackTrace(); + } + if (this.value173 > (getWidth() - image172.getWidth()) / 2) { + this.value173 -= 2; + } + repaint(); + } + } + + /* renamed from: c */ + private static void execute224() { + image172 = null; + } + + /* renamed from: a */ + public static void execute225() { + MainUiCanvasBase.loadMenuResources(); + } + + /* renamed from: b */ + public static void execute226() { + execute224(); + MainUiCanvasBase.unloadMenuResources(); + } +} diff --git a/p000/VectorMath.java b/p000/VectorMath.java new file mode 100644 index 0000000..f074f02 --- /dev/null +++ b/p000/VectorMath.java @@ -0,0 +1,71 @@ +package p000; + +/* renamed from: o */ +/* loaded from: microcounterstrike.jar:o.class */ +public final class VectorMath { + /* renamed from: a */ + public static float getFloat259(float[] fArr, float[] fArr2) { + if (fArr.length != fArr2.length) { + throw new ArithmeticException(); + } + float f = 0.0f; + for (int i = 0; i < fArr.length; i++) { + f += fArr[i] * fArr2[i]; + } + return f; + } + + /* renamed from: b */ + public static float[] getFloatArray260(float[] fArr, float[] fArr2) { + if (fArr.length == 3 && fArr2.length == 3) { + return new float[]{(fArr[1] * fArr2[2]) - (fArr[2] * fArr2[1]), (fArr[2] * fArr2[0]) - (fArr[0] * fArr2[2]), (fArr[0] * fArr2[1]) - (fArr[1] * fArr2[0])}; + } + throw new ArithmeticException(); + } + + /* renamed from: a */ + public static float getFloat261(float[] fArr) { + float f = 0.0f; + for (int i = 0; i < fArr.length; i++) { + f += fArr[i] * fArr[i]; + } + return (float) Math.sqrt(f); + } + + /* renamed from: c */ + public static float[] getFloatArray262(float[] fArr, float[] fArr2) { + return new float[]{fArr[0] + fArr2[0], fArr[1] + fArr2[1], fArr[2] + fArr2[2]}; + } + + /* renamed from: b */ + public static float[] getFloatArray263(float[] fArr) { + float fM261a = getFloat261(fArr); + float[] fArr2 = new float[fArr.length]; + for (int i = 0; i < fArr2.length; i++) { + fArr2[i] = fArr[i] / fM261a; + } + return fArr2; + } + + /* renamed from: e */ + private static float[] getFloatArray264(float[] fArr, float[] fArr2) { + float fM259a = getFloat259(fArr, fArr2); + float fM261a = getFloat261(fArr2); + float f = fM259a / (fM261a * fM261a); + float[] fArr3 = new float[3]; + for (int i = 0; i < fArr3.length; i++) { + fArr3[i] = fArr2[i] * f; + } + return fArr3; + } + + /* renamed from: d */ + public static float[] getFloatArray265(float[] fArr, float[] fArr2) { + float[] fArrM264e = getFloatArray264(fArr, fArr2); + float[] fArr3 = new float[3]; + for (int i = 0; i < fArr3.length; i++) { + fArr3[i] = fArr[i] - fArrM264e[i]; + } + return fArr3; + } +} diff --git a/p000/WeaponInfo.java b/p000/WeaponInfo.java new file mode 100644 index 0000000..2a92d6c --- /dev/null +++ b/p000/WeaponInfo.java @@ -0,0 +1,36 @@ +package p000; + +/* renamed from: k */ +/* loaded from: microcounterstrike.jar:k.class */ +public final class WeaponInfo { + + /* renamed from: a */ + public int weaponId; + + /* renamed from: b */ + public String name; + + /* renamed from: c */ + public int clipSize; + + /* renamed from: d */ + public int defaultAmmo; + + /* renamed from: e */ + public String weightLabel; + + /* renamed from: f */ + public int cost; + + /* renamed from: g */ + public int weaponCode; + + /* renamed from: h */ + public int[][][] recoilPattern; + + /* renamed from: i */ + public int[][] crosshairPattern; + + /* renamed from: j */ + public int damage; +} diff --git a/p000/WeaponLoadout.java b/p000/WeaponLoadout.java new file mode 100644 index 0000000..0c69495 --- /dev/null +++ b/p000/WeaponLoadout.java @@ -0,0 +1,159 @@ +package p000; + +import java.util.Vector; + +/* renamed from: az */ +/* loaded from: microcounterstrike.jar:az.class */ +public final class WeaponLoadout { + + /* renamed from: a */ + public static Vector weaponCatalog = null; + + /* renamed from: b */ + public static int defaultPrimaryWeaponId = -1; + + /* renamed from: c */ + public static int defaultPistolWeaponId = -1; + + /* renamed from: d */ + public static int defaultKnifeWeaponId = -1; + + /* renamed from: e */ + public static int defaultAmmoPack1WeaponId = -1; + + /* renamed from: f */ + public static int defaultAmmoPack2WeaponId = -1; + + /* renamed from: i */ + public int activeSlot; + + /* renamed from: g */ + public int[] equippedWeaponIdBySlot = {-1, -1, -1, -1}; + + /* renamed from: h */ + public int[] ammoBySlot = new int[4]; + + /* renamed from: j */ + public int grenadeCharge = 0; + + public WeaponLoadout() { + weaponCatalog = new Vector(); + PlatformServices.getInstance().loadWeaponDefinitions(MainUiCanvasBase.getInstance().value183); + } + + /* renamed from: a */ + public static void registerWeapon(WeaponInfo c0042k) { + weaponCatalog.addElement(c0042k); + c0042k.weaponId = weaponCatalog.indexOf(c0042k); + if (defaultPrimaryWeaponId == -1 && c0042k.weaponCode / 10 == 1) { + defaultPrimaryWeaponId = c0042k.weaponId; + return; + } + if (defaultPistolWeaponId == -1 && c0042k.weaponCode / 10 == 2) { + defaultPistolWeaponId = c0042k.weaponId; + return; + } + if (defaultKnifeWeaponId == -1 && c0042k.weaponCode / 10 == 3) { + defaultKnifeWeaponId = c0042k.weaponId; + return; + } + if (defaultAmmoPack1WeaponId == -1 && c0042k.weaponCode == 50) { + defaultAmmoPack1WeaponId = c0042k.weaponId; + } else if (defaultAmmoPack2WeaponId == -1 && c0042k.weaponCode == 51) { + defaultAmmoPack2WeaponId = c0042k.weaponId; + } + } + + /* renamed from: a */ + public final void resetToDefaultLoadout() { + if (PlatformServices.getInstance().getBoolean152()) { + this.equippedWeaponIdBySlot[0] = MainUiCanvasBase.getInstance().value184; + this.ammoBySlot[0] = ((WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[0])).clipSize * 3; + this.equippedWeaponIdBySlot[1] = MainUiCanvasBase.getInstance().value185; + this.ammoBySlot[1] = ((WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[1])).clipSize * 5; + this.equippedWeaponIdBySlot[2] = defaultKnifeWeaponId; + this.equippedWeaponIdBySlot[3] = MainUiCanvasBase.getInstance().value186; + this.ammoBySlot[3] = ((WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[3])).clipSize * 5; + selectSlot(1); + } else { + this.equippedWeaponIdBySlot[0] = -1; + this.ammoBySlot[0] = 0; + this.equippedWeaponIdBySlot[1] = defaultPistolWeaponId; + this.ammoBySlot[1] = ((WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[1])).defaultAmmo; + this.equippedWeaponIdBySlot[2] = defaultKnifeWeaponId; + this.equippedWeaponIdBySlot[3] = -1; + this.ammoBySlot[3] = 0; + selectSlot(2); + } + this.grenadeCharge = 0; + } + + /* renamed from: b */ + public final void consumeAmmo() { + int[] iArr = this.ammoBySlot; + int i = this.activeSlot - 1; + iArr[i] = iArr[i] - 1; + } + + /* renamed from: a */ + public final boolean selectSlot(int i) { + if (this.equippedWeaponIdBySlot[i - 1] == -1) { + return false; + } + this.activeSlot = i; + return true; + } + + /* renamed from: c */ + public final int getActiveAmmo() { + return this.ammoBySlot[this.activeSlot - 1]; + } + + /* renamed from: d */ + public final WeaponInfo getActiveWeaponInfo() { + return (WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[this.activeSlot - 1]); + } + + /* JADX WARN: Multi-variable type inference failed */ + /* renamed from: b */ + public final void addWeaponOrAmmo(WeaponInfo c0042k) { + int i = c0042k.weaponCode / 10; + if (i == 1 || i == 2 || i == 4) { + this.equippedWeaponIdBySlot[i - 1] = c0042k.weaponId; + this.ammoBySlot[i - 1] = c0042k.defaultAmmo; + selectSlot(i); + } else { + if (i != 5) { + if (i == 6 && c0042k.weaponCode == 60) { + this.grenadeCharge = 100; + return; + } + return; + } + byte b = false; + if (c0042k.weaponCode == 51) { + b = true; + } + int[] iArr = this.ammoBySlot; + byte b2 = b; + iArr[b2 == true ? 1 : 0] = iArr[b2 == true ? 1 : 0] + ((WeaponInfo) weaponCatalog.elementAt(this.equippedWeaponIdBySlot[b == true ? 1 : 0])).clipSize; + } + } + + /* renamed from: b */ + public final void clearSlot(int i) { + this.equippedWeaponIdBySlot[i - 1] = -1; + this.ammoBySlot[i - 1] = 0; + } + + /* renamed from: e */ + public final void dispose() { + this.equippedWeaponIdBySlot = null; + this.ammoBySlot = null; + } + + /* renamed from: f */ + public static void clearWeaponCatalog() { + weaponCatalog = null; + } +}