Initialize local project and fix ranch growth synchronization

This commit is contained in:
AttilaNet
2026-11-07 22:14:49 +08:00
commit 657f5f33b5
1417 changed files with 202171 additions and 0 deletions
@@ -0,0 +1,45 @@
package net.pixvi.common.net
{
import net.pixvi.common.manager.resource.ConfigManager;
import net.pixvi.pfw.net.PiStringLoader;
import net.pixvi.pfw.utils.core.Singleton;
public class ConfigLoader extends Singleton
{
private var _onLoaded:Function;
private var loader:PiStringLoader;
private var srcHack:Object = {};
public function ConfigLoader()
{
super();
loader = new PiStringLoader();
}
public static function getInstance() : ConfigLoader
{
return Singleton.getInstanceOrCreate(ConfigLoader) as ConfigLoader;
}
public function loadConfig(src:String, onloaded:Function = null, onerror:Function = null, crypto:Boolean = false, srcHack:Object = null) : void
{
this._onLoaded = onloaded;
if(srcHack != null)
{
this.srcHack = srcHack;
}
loader.cryptoMode = crypto;
loader.load(src,completeHandler,null,onerror);
}
private function completeHandler() : void
{
ConfigManager.getInstance().setup(new XML(loader.getData()),srcHack);
this._onLoaded.call();
}
}
}
@@ -0,0 +1,168 @@
package net.pixvi.common.net.remote
{
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.TimerEvent;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestHeader;
import flash.utils.Timer;
public class HttpRemote
{
public static const TRADITIONAL_DATAFORMAT:String = "traditional";
public static const JSON_DATAFORMAT:String = "jsonDataFormat";
public var _callBackFun:Function;
private var _errorFun:Function;
private var _loader:URLLoader;
private var _request:URLRequest;
private var overTimer:Timer;
public var url:String;
private var _data:Object;
public var retryMode:Boolean = false;
public var cryptoMode:Boolean = false;
public var waiting:Boolean = true;
public var errorBack:Boolean = false;
public function HttpRemote(url:String, sendData:Object, callBackFun:Function = null, errorFun:Function = null, requestHeaders:Array = null, overTime:int = 1500, dataFormat:String = "text")
{
var i:int = 0;
super();
this.url = url;
this._callBackFun = callBackFun;
this._errorFun = errorFun;
var request:URLRequest = new URLRequest(url);
_loader = new URLLoader();
if(dataFormat == "text")
{
request.contentType = "text/xml";
_loader.dataFormat = "text";
}
else if(dataFormat == "binary")
{
request.contentType = "application/octet-stream";
_loader.dataFormat = "binary";
}
else if(dataFormat == "variables")
{
request.contentType = "application/x-www-form-urlencoded";
_loader.dataFormat = "binary";
}
else if(dataFormat == "traditional")
{
request.contentType = "application/x-www-form-urlencoded";
_loader.dataFormat = "text";
}
else if(dataFormat == "jsonDataFormat")
{
request.contentType = "application/json;charset=UTF-8";
_loader.dataFormat = "text";
}
var rhArray:Array = [];
if(requestHeaders != null)
{
for(i = 0; i < requestHeaders.length; )
{
rhArray.push(new URLRequestHeader(requestHeaders[i][0],requestHeaders[i][1]));
i++;
}
}
request.data = sendData;
_data = sendData;
request.method = "POST";
request.requestHeaders = rhArray;
_request = request;
if(overTime > 0)
{
overTimer = new Timer(overTime,1);
overTimer.addEventListener("timerComplete",timerHandler);
}
}
public function start() : void
{
if(overTimer != null)
{
overTimer.start();
}
_loader.addEventListener("complete",completeHandler);
_loader.addEventListener("ioError",errorHandler);
trace("【loadURL】 " + _request.url);
_loader.load(_request);
}
protected function timerHandler(e:TimerEvent) : void
{
errorHandler(null);
}
private function completeHandler(e:Event) : void
{
trace("【loadData】 " + e.target.data);
this._callBackFun(e.target.data);
this._callBackFun = null;
this._errorFun = null;
if(overTimer != null)
{
overTimer.stop();
overTimer.removeEventListener("timerComplete",timerHandler);
}
}
private function errorHandler(event:IOErrorEvent) : void
{
if(overTimer != null)
{
overTimer.reset();
}
_loader.removeEventListener("ioError",errorHandler);
if(this._errorFun != null)
{
if(event == null)
{
event = new IOErrorEvent("ioError");
event.text = "[HttpRemote]请求超时(" + int(overTimer.delay / 1000) + "s)!url:" + url;
}
this._errorFun(event);
}
if(!retryMode)
{
clear();
}
}
private function clear() : void
{
_loader.removeEventListener("complete",completeHandler);
_loader.removeEventListener("ioError",errorHandler);
if(overTimer != null)
{
overTimer.stop();
overTimer.removeEventListener("timerComplete",timerHandler);
overTimer = null;
}
_loader = null;
this._callBackFun = null;
this._errorFun = null;
}
public function get data() : Object
{
return _data;
}
}
}
@@ -0,0 +1,20 @@
package net.pixvi.common.net.remote
{
public class HttpRemoteContentType
{
public static const TEXT_XML:String = "text/xml";
public static const APPLICATION_OCTET_STREAM:String = "application/octet-stream";
public static const X_WWW_FORM_URLENCODED:String = "application/x-www-form-urlencoded";
public static const JSON_CONTENT:String = "application/json;charset=UTF-8";
public function HttpRemoteContentType()
{
super();
}
}
}
@@ -0,0 +1,223 @@
package net.pixvi.common.net.resource
{
import flash.events.ErrorEvent;
import net.pixvi.common.SysSetting;
import net.pixvi.common.manager.resource.RM;
import net.pixvi.pfw.net.PiDisplayLoader;
import net.pixvi.pfw.net.base.PiLoader;
public class ResourceLoader extends PiLoader
{
private var _resourceList:Array;
private var _resource:ResourceVo;
private var _flag:int = 0;
private var loader:PiLoader;
private var _allBytesLoaded:int = 0;
private var _allBytesTotal:int = 0;
public function ResourceLoader()
{
super();
}
override public function load(list:*, onComplete:Function = null, onProgress:Function = null, onError:Function = null) : void
{
var resourceArr:Array = null;
if(list is Vector.<ResourceVo>)
{
resourceArr = [];
for each(var rv:ResourceVo in list)
{
resourceArr.push(rv);
}
_resourceList = resourceArr;
}
else
{
_resourceList = list;
}
super.load(_resourceList,onComplete,onProgress,onError);
}
public function get filesTotal() : int
{
return _resourceList.length;
}
public function get filesLoaded() : int
{
return _flag;
}
override public function doLoad() : void
{
startCurrentLoader();
}
public function getResource(id:String) : ResourceVo
{
for each(var r:ResourceVo in _resourceList)
{
if(r.id == id)
{
return r;
}
}
return null;
}
private function startCurrentLoader() : void
{
if(_flag < _resourceList.length)
{
_resource = _resourceList[_flag];
trace("[ResourceLoader]" + _resource.src + " " + _flag);
if(_resource.loaded)
{
_allBytesLoaded += _resource.size;
_flag++;
startCurrentLoader();
}
else
{
if(_resource.type == null || _resource.type == "")
{
_resource.setBySrc(_resource.src);
}
loader = ResourceType.createLoader(_resource.type,_resource.crypto,_resource.binaryMode);
loader.load(_resource.src,loaderComplete,loaderProgress,loaderError);
}
}
else
{
completeHandler();
removeHandler();
}
}
public function get curResource() : ResourceVo
{
return _resource;
}
private function loaderComplete() : void
{
_flag++;
_allBytesLoaded += loader.bytesTotal;
trace(loader + "【加载完毕】" + loader.src + "[" + loader.bytesTotal + "]");
if(loader is PiDisplayLoader)
{
trace("binaryMode:" + (loader as PiDisplayLoader).binaryMode);
}
loader.removeHandler();
_resource.data = loader.getData();
RM.getInstance().add(_resource);
loader = null;
startCurrentLoader();
}
private function loaderProgress() : void
{
if(loader.bytesTotal > 0 && _resource.size != loader.bytesLoaded)
{
_resource.size = loader.bytesTotal;
}
progressHandler();
}
private function loaderError(e:ErrorEvent) : void
{
loader.removeHandler();
loader.unload();
if(_resource.retryCount < SysSetting.maxRetry)
{
trace("资源" + _resource.src + "加载失败!重试: " + _resource.retryCount + 1);
_resource.retryCount++;
startCurrentLoader();
return;
}
throw new Error("资源" + _resource.src + "加载失败!");
}
public function get allBytesTotal() : uint
{
var i:int = 0;
_allBytesTotal = 0;
var len:int = int(_resourceList.length);
for(i = 0; i < len; )
{
if(_resourceList[i].size && !_resourceList[i].failed)
{
_allBytesTotal += _resourceList[i].size;
}
i++;
}
return _allBytesTotal;
}
public function get allBytesLoaded() : uint
{
if(loader != null)
{
return _allBytesLoaded + loader.bytesLoaded;
}
return _allBytesLoaded;
}
override public function stopLoad() : void
{
if(loader != null)
{
loader.stopLoad();
}
}
override public function getData() : *
{
return _resourceList;
}
public function get smartLoadedPercent() : Number
{
return filesLoaded / filesTotal + bytesLoaded / bytesTotal * (1 / filesTotal);
}
public function get loadedPercent() : Number
{
return allBytesLoaded / allBytesTotal;
}
override public function get bytesLoaded() : int
{
if(loader != null)
{
return loader.bytesLoaded;
}
return 0;
}
override public function get bytesTotal() : int
{
if(loader != null)
{
return loader.bytesTotal;
}
return 0;
}
public function removeAllResource() : void
{
for each(var r:ResourceVo in _resourceList)
{
RM.getInstance().remove(r);
}
}
}
}
@@ -0,0 +1,85 @@
package net.pixvi.common.net.resource
{
import net.pixvi.pfw.display.NetImg;
import net.pixvi.pfw.net.PiByteLoader;
import net.pixvi.pfw.net.PiDisplayLoader;
import net.pixvi.pfw.net.PiSoundLoader;
import net.pixvi.pfw.net.PiStringLoader;
import net.pixvi.pfw.net.base.PiLoader;
public class ResourceType
{
public static const SWF:String = "swf";
public static const XML:String = "xml";
public static const JPG:String = "jpg";
public static const PNG:String = "png";
public static const CSV:String = "csv";
public static const MP3:String = "mp3";
public static const BYTE:String = "byte";
public static const TXT:String = "txt";
public static const JSON:String = "json";
public function ResourceType()
{
super();
}
public static function createLoader(type:String, crypto:Boolean = false, binaryMode:Boolean = false) : PiLoader
{
var loader:PiLoader = null;
switch(type)
{
case "jpg":
case "png":
case "swf":
loader = new PiDisplayLoader();
if((type == "jpg" || type == "png") && NetImg.globalImgCryptoMode)
{
(loader as PiDisplayLoader).cryptoMode = true;
}
if(type == "swf" && binaryMode)
{
(loader as PiDisplayLoader).binaryMode = true;
}
break;
case "xml":
case "csv":
case "txt":
loader = new PiStringLoader();
if(crypto)
{
(loader as PiStringLoader).cryptoMode = true;
}
break;
case "json":
if(crypto && PiStringLoader.globalCryptoMode)
{
loader = new PiByteLoader();
loader["jsonCryptoMode"] = true;
}
else
{
loader = new PiStringLoader();
}
break;
case "mp3":
loader = new PiSoundLoader();
break;
default:
case "byte":
loader = new PiByteLoader();
}
return loader;
}
}
}
@@ -0,0 +1,107 @@
package net.pixvi.common.net.resource
{
import net.pixvi.pfw.interfaces.IDispose;
public class ResourceVo implements IDispose
{
public var id:String;
public var src:String;
public var type:String;
public var size:int;
public var loadwhenstart:int;
public var team:String;
public var param:String;
public var paramObj:Object;
public var crypto:Boolean = false;
public var binaryMode:Boolean = false;
private var _loaded:Boolean;
private var _failed:Boolean = false;
public var retryCount:int = 0;
private var _data:*;
public function ResourceVo(src:String = "")
{
super();
_loaded = false;
paramObj = {};
if(src != "")
{
setBySrc(src);
}
}
public function setBySrc(src:String) : void
{
this.src = src;
var tag:Array = src.split("/");
var file:String = tag[tag.length - 1];
tag = file.split(".");
type = tag[1];
id = tag[0];
loaded = false;
size = -1;
}
public function get loaded() : Boolean
{
return _loaded;
}
public function get data() : *
{
return _data;
}
public function set data(value:*) : void
{
_data = value;
if(!loaded)
{
_loaded = true;
}
}
public function removeData() : void
{
_data = null;
_loaded = false;
}
public function get failed() : Boolean
{
return _failed;
}
public function set failed(value:Boolean) : void
{
_failed = value;
}
public function dispose() : void
{
_loaded = false;
_failed = false;
_data = null;
}
public function set loaded(value:Boolean) : void
{
_loaded = value;
}
}
}